@learnpack/learnpack 5.0.238 → 5.0.244

package/lib/commands/init.js

@@ -270,8 +270,12 @@ const handleAILogic = async (tutorialDir, packageInfo) => {
     const imagePromises = imagesArray.map(async (image) => {
         try {
             const filename = (0, creatorUtilities_1.getFilenameFromUrl)(image.url);
+            const webhookUrl = `${process.env.HOST}/webhooks/${(0, creatorUtilities_1.slugify)(packageInfo.title.us)}/images/${filename}`;
             const imagePath = path.join(tutorialDir, ".learn", "assets", filename);
-            const res = await (0, rigoActions_1.generateImage)(rigoToken, { prompt: image.alt });
+            const res = await (0, rigoActions_1.generateImage)(rigoToken, {
+                prompt: image.alt,
+                callbackUrl: webhookUrl,
+            });
             await (0, rigoActions_1.downloadImage)(res.image_url, imagePath);
             return true;
         }
@@ -289,8 +293,9 @@ const handleAILogic = async (tutorialDir, packageInfo) => {
         prompt: "Generate a preview image for the tutorial. This is all the tutorial information: " +
             packageContext +
             "\n Generate only a basic preview image, add the tutorial Title as a text add the top middle, avoid adding any other text elements. Try to generate an image that related with the tutorial content.",
+        callbackUrl: `${process.env.HOST}/webhooks/${(0, creatorUtilities_1.slugify)(packageInfo.title.us)}/images/preview.png`,
     });
-    await (0, rigoActions_1.downloadImage)(res.image_url, imagePath);
+    // await downloadImage(res.image_url, imagePath)
     return true;
 };
 const getChoices = async (empty) => {

package/lib/commands/publish.d.ts

@@ -2,7 +2,7 @@ import SessionCommand from "../utils/SessionCommand";
 export declare const handleAssetCreation: (sessionPayload: {
     token: string;
     rigobotToken: string;
-}, learnJson: any, selectedLang: string, learnpackDeployUrl: string) => Promise<void>;
+}, learnJson: any, selectedLang: string, learnpackDeployUrl: string, b64IndexReadme: string, all_translations?: string[]) => Promise<any>;
 declare class BuildCommand extends SessionCommand {
     static description: string;
     static flags: {

package/lib/commands/publish.js

@@ -18,11 +18,12 @@ const api_1 = require("../utils/api");
 const prompts = require("prompts");
 const rigoActions_1 = require("../utils/rigoActions");
 const misc_1 = require("../utils/misc");
+const creatorUtilities_1 = require("../utils/creatorUtilities");
 const uploadZipEndpont = api_1.RIGOBOT_HOST + "/v1/learnpack/upload";
-const handleAssetCreation = async (sessionPayload, learnJson, selectedLang, learnpackDeployUrl) => {
+const handleAssetCreation = async (sessionPayload, learnJson, selectedLang, learnpackDeployUrl, b64IndexReadme, all_translations = []) => {
     const categories = {
-        us: 91,
-        es: 92,
+        us: 9,
+        es: 10,
     };
     let category = categories[selectedLang];
     if (!category) {
@@ -30,11 +31,12 @@ const handleAssetCreation = async (sessionPayload, learnJson, selectedLang, lear
     }
     try {
         const user = await api_1.default.validateToken(sessionPayload.token);
-        const { exists } = await api_1.default.doesAssetExists(sessionPayload.token, learnJson.slug);
+        const slug = (0, creatorUtilities_1.slugify)(learnJson.title[selectedLang]).slice(0, 50);
+        const { exists } = await api_1.default.doesAssetExists(sessionPayload.token, slug);
         if (!exists) {
             console_1.default.info("Asset does not exist in this academy, creating it");
             const asset = await api_1.default.createAsset(sessionPayload.token, {
-                slug: learnJson.slug,
+                slug: slug,
                 title: learnJson.title[selectedLang],
                 lang: selectedLang,
                 description: learnJson.description[selectedLang],
@@ -45,23 +47,27 @@ const handleAssetCreation = async (sessionPayload, learnJson, selectedLang, lear
                 owner: user.id,
                 author: user.id,
                 preview: learnJson.preview,
+                readme_raw: b64IndexReadme,
+                all_translations,
             });
             await api_1.default.updateRigoAssetID(sessionPayload.token, learnJson.slug, asset.id);
             console_1.default.info("Asset created with id", asset.id);
+            return asset;
         }
-        else {
-            console_1.default.info("Asset exists, updating it");
-            const asset = await api_1.default.updateAsset(sessionPayload.token, learnJson.slug, {
-                learnpack_deploy_url: learnpackDeployUrl,
-                title: learnJson.title[selectedLang],
-                description: learnJson.description[selectedLang],
-            });
-            await api_1.default.updateRigoAssetID(sessionPayload.rigobotToken, learnJson.slug, asset.id);
-            console_1.default.info("Asset updated with id", asset.id);
-        }
+        console_1.default.info("Asset exists, updating it");
+        const asset = await api_1.default.updateAsset(sessionPayload.token, slug, {
+            learnpack_deploy_url: learnpackDeployUrl,
+            title: learnJson.title[selectedLang],
+            description: learnJson.description[selectedLang],
+            all_translations,
+        });
+        await api_1.default.updateRigoAssetID(sessionPayload.rigobotToken.trim(), learnJson.slug, asset.id);
+        console_1.default.info("Asset updated with id", asset.id);
+        return asset;
     }
     catch (error) {
         console_1.default.error("Error updating or creating asset:", error);
+        return null;
     }
 };
 exports.handleAssetCreation = handleAssetCreation;
@@ -295,7 +301,7 @@ class BuildCommand extends SessionCommand_1.default {
                 console.log(res.data);
                 fs.unlinkSync(zipFilePath);
                 this.removeDirectory(buildDir);
-                await (0, exports.handleAssetCreation)(sessionPayload, learnJson, "us", res.data.url);
+                await (0, exports.handleAssetCreation)(sessionPayload, learnJson, "us", res.data.url, "", []);
             }
             catch (error) {
                 if (axios_1.default.isAxiosError(error)) {

package/lib/commands/serve.d.ts

@@ -1,5 +1,4 @@
 import SessionCommand from "../utils/SessionCommand";
-import { Bucket } from "@google-cloud/storage";
 import { FormState } from "../models/creator";
 export declare const createLearnJson: (courseInfo: FormState) => {
     slug: string;
@@ -20,7 +19,7 @@ export declare const createLearnJson: (courseInfo: FormState) => {
     };
     preview: string;
 };
-export declare const processImage: (bucket: Bucket, tutorialDir: string, url: string, description: string, rigoToken: string) => Promise<boolean>;
+export declare const processImage: (url: string, description: string, rigoToken: string, courseSlug: string) => Promise<boolean>;
 export default class ServeCommand extends SessionCommand {
     static description: string;
     static flags: any;

package/lib/commands/serve.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processImage = exports.createLearnJson = void 0;
 const tslib_1 = require("tslib");
 const command_1 = require("@oclif/command");
-// import { readDocument } from "../utils/readDocuments"
 const youtube_transcript_1 = require("youtube-transcript");
 const express = require("express");
 const cors = require("cors");
@@ -42,11 +41,11 @@ function findLast(array, predicate) {
 }
 const createLearnJson = (courseInfo) => {
     // console.log("courseInfo to create learn json", courseInfo)
-    const expectedPreviewUrl = `https://${(0, creatorUtilities_2.slugify)(courseInfo.title)}.learn-pack.com/preview.png`;
+    const expectedPreviewUrl = `https://${courseInfo.slug}.learn-pack.com/preview.png`;
     console.log("Preview url in generated learn.json", expectedPreviewUrl);
     const language = courseInfo.language || "en";
     const learnJson = {
-        slug: (0, creatorUtilities_2.slugify)(courseInfo.title),
+        slug: courseInfo.slug,
         title: language === "en" || language === "us" ?
             {
                 us: courseInfo.title,
@@ -72,19 +71,6 @@ const uploadFileToBucket = async (bucket, file, path) => {
     const fileRef = bucket.file(path);
     await fileRef.save(Buffer.from(file, "utf8"));
 };
-const uploadImageToBucket = async (bucket, url, path) => {
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to download image: ${response.statusText}`);
-    }
-    const contentType = response.headers.get("content-type") || "application/octet-stream";
-    const buffer = await response.arrayBuffer();
-    const fileRef = bucket.file(path);
-    await fileRef.save(Buffer.from(buffer), {
-        resumable: false,
-        contentType,
-    });
-};
 const PARAMS = {
     expected_grade_level: "8",
     max_fkgl: 10,
@@ -92,16 +78,16 @@ const PARAMS = {
     max_rewrite_attempts: 2,
     max_title_length: 50,
 };
-const processImage = async (bucket, tutorialDir, url, description, rigoToken) => {
+const processImage = async (url, description, rigoToken, courseSlug) => {
     try {
         // TODO: MAKE THIS ASYNC
         const filename = (0, creatorUtilities_1.getFilenameFromUrl)(url);
-        console.log("🖼️ IMAGE FILENAME", filename);
-        const imagePath = `${tutorialDir}/.learn/assets/${filename}`;
-        console.log("🖼️ Generating image", imagePath);
-        const res = await (0, rigoActions_1.generateImage)(rigoToken, { prompt: description });
-        await uploadImageToBucket(bucket, res.image_url, imagePath);
-        console.log("✅ Image", imagePath, "generated successfully!");
+        const webhookUrl = `${process.env.HOST}/webhooks/${courseSlug}/images/${filename}`;
+        await (0, rigoActions_1.generateImage)(rigoToken, {
+            prompt: description,
+            callbackUrl: webhookUrl,
+        });
+        // console.log("✅ Image", imagePath, "generated successfully!")
         return true;
     }
     catch (_a) {
@@ -131,10 +117,31 @@ const uploadInitialReadme = async (bucket, exSlug, targetDir, packageContext) =>
     await uploadFileToBucket(bucket, isGeneratingText, `${targetDir}/${readmeFilename}`);
 };
 const cleanFormState = (formState) => {
-    // keysToDelete: description, technologies, purpose
     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"]);
     return rest;
 };
+const createMultiLangAsset = async (bucket, rigoToken, bcToken, courseSlug, courseJson, deployUrl) => {
+    const availableLangs = Object.keys(courseJson.title);
+    console.log("AVAILABLE LANGUAGES to upload asset", availableLangs);
+    const all_translations = [];
+    for (const lang of availableLangs) {
+        // eslint-disable-next-line no-await-in-loop
+        const indexReadme = await bucket.file(`courses/${courseSlug}/README.${lang === "us" || lang === "en" ? "md" : `${lang}.md`}`);
+        // eslint-disable-next-line no-await-in-loop
+        const [indexReadmeContent] = await indexReadme.download();
+        const indexReadmeString = indexReadmeContent.toString();
+        const b64IndexReadme = Buffer.from(indexReadmeString).toString("base64");
+        // eslint-disable-next-line no-await-in-loop
+        const asset = await (0, publish_1.handleAssetCreation)({ token: bcToken, rigobotToken: rigoToken }, courseJson, lang, deployUrl, b64IndexReadme, all_translations);
+        all_translations.push(asset.slug);
+    }
+    // const languageCodes = new Set(languageCodes)
+    // const asset = await api.createAsset(rigoToken, {
+    //   slug: courseSlug,
+    //   title: courseJson.title,
+    //   description: courseJson.description,
+    // })
+};
 async function startExerciseGeneration(bucket, rigoToken, steps, packageContext, exercise, tutorialDir, courseSlug, purposeSlug, lastLesson = "") {
     const exSlug = (0, creatorUtilities_2.slugify)(exercise.id + "-" + exercise.title);
     console.log("Starting generation of", exSlug);
@@ -150,6 +157,19 @@ async function startExerciseGeneration(bucket, rigoToken, steps, packageContext,
         last_lesson: lastLesson,
     }, purposeSlug, webhookUrl);
 }
+async function createInitialReadme(tutorialInfo, tutorialSlug, rigoToken) {
+    const webhookUrl = `${process.env.HOST}/webhooks/${tutorialSlug}/initial-readme-processor`;
+    console.log("Creating initial readme", webhookUrl);
+    try {
+        const res = await (0, rigoActions_1.createStructuredPreviewReadme)(rigoToken, {
+            tutorial_info: tutorialInfo,
+        }, webhookUrl);
+        console.log("Initial readme created", res);
+    }
+    catch (error) {
+        console.error("Error creating initial readme", error);
+    }
+}
 const fixPreviewUrl = (slug, previewUrl) => {
     if (!previewUrl) {
         return null;
@@ -315,6 +335,19 @@ class ServeCommand extends SessionCommand_1.default {
             (0, creatorSocket_1.emitToNotification)(id, body);
             res.json({ id, status: "SUCCESS" });
         });
+        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.${body.parsed.language_code === "us" ||
+                body.parsed.language_code === "en" ?
+                "md" :
+                `${body.parsed.language_code}.md`}`;
+            console.log("Saving initial readme to", filePath);
+            await uploadFileToBucket(bucket, body.parsed.content, filePath);
+            console.log("Initial readme saved to", filePath);
+            res.json({ status: "SUCCESS" });
+        });
         app.post("/webhooks/:courseSlug/images/:imageId", async (req, res) => {
             const { courseSlug, imageId } = req.params;
             const body = req.body;
@@ -401,7 +434,7 @@ class ServeCommand extends SessionCommand_1.default {
                 });
                 for (const image of imagesArray) {
                     // eslint-disable-next-line no-await-in-loop
-                    await (0, exports.processImage)(bucket, `courses/${courseSlug}`, image.url, image.alt, rigoToken);
+                    await (0, exports.processImage)(image.url, image.alt, rigoToken, courseSlug);
                 }
             }
             (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
@@ -572,19 +605,23 @@ class ServeCommand extends SessionCommand_1.default {
         });
         app.post("/actions/translate", express.json(), async (req, res) => {
             console.log("POST /actions/translate");
-            const { exerciseSlugs, languages, rigoToken } = req.body;
+            const { exerciseSlugs, languages, rigoToken, currentLanguage } = req.body;
             const query = req.query;
             const courseSlug = query.slug;
-            console.log("EXERCISE SLUGS", exerciseSlugs);
-            console.log("LANGUAGES", languages);
-            console.log("RIGO TOKEN", rigoToken);
             if (!rigoToken) {
                 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();
             try {
                 await Promise.all(exerciseSlugs.map(async (slug) => {
-                    const readmePath = `courses/${courseSlug}/exercises/${slug}/README.md`;
+                    const readmePath = `courses/${courseSlug}/exercises/${slug}/README${currentLanguage === "us" || currentLanguage === "en" ?
+                        "" :
+                        `.${currentLanguage}`}.md`;
                     const readme = await bucket.file(readmePath).download();
                     await Promise.all(languagesToTranslate.map(async (language) => {
                         const response = await (0, rigoActions_1.translateExercise)(rigoToken, {
@@ -592,10 +629,62 @@ class ServeCommand extends SessionCommand_1.default {
                             output_language: language,
                             exercise_slug: slug,
                         });
-                        const translatedReadme = await bucket.file(`courses/${courseSlug}/exercises/${slug}/README.${response.parsed.output_language_code}.md`);
+                        const translatedReadme = await bucket.file(`courses/${courseSlug}/exercises/${slug}/README${response.parsed.output_language_code === "us" ||
+                            response.parsed.output_language_code === "en" ?
+                            "" :
+                            `.${response.parsed.output_language_code}`}.md`);
                         await translatedReadme.save(response.parsed.translation);
+                        languageCodes.add(response.parsed.output_language_code);
                     }));
                 }));
+                if (languageCodes.has("en")) {
+                    languageCodes.delete("en");
+                    languageCodes.add("us");
+                }
+                const currentLanguages = Object.keys(courseJson.title);
+                for (const languageCode of currentLanguages) {
+                    if (languageCodes.has(languageCode)) {
+                        languageCodes.delete(languageCode);
+                    }
+                }
+                if ([...languageCodes].length > 0) {
+                    console.log("TRANSLATING COURSE METADATA", languageCodes);
+                    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;
+                    }
+                    await uploadFileToBucket(bucket, JSON.stringify(courseJson), `courses/${courseSlug}/learn.json`);
+                    const previewReadme = await bucket.file(`courses/${courseSlug}/README${currentLanguage === "us" || currentLanguage === "en" ?
+                        "" :
+                        `.${currentLanguage}`}.md`);
+                    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${languageCode === "us" || languageCode === "en" ?
+                            "" :
+                            `.${languageCode}`}.md`)
+                            .save(translatedPreviewReadme.parsed.translation);
+                    }));
+                }
                 return res.status(200).json({ message: "Translated exercises" });
             }
             catch (error) {
@@ -604,6 +693,7 @@ class ServeCommand extends SessionCommand_1.default {
             }
         });
         app.delete("/exercise/:slug/delete", async (req, res) => {
+            console.log("DELETE /exercise/:slug/delete");
             const { slug } = req.params;
             const query = req.query;
             const courseSlug = query.slug;
@@ -639,53 +729,23 @@ class ServeCommand extends SessionCommand_1.default {
             }
             catch (error) {
                 if (error.code === 404) {
-                    console.log("SIDEBAR FILE NOT FOUND", courseSlug);
                     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`);
                     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 uploadFileToBucket(bucket, JSON.stringify(sidebar), `courses/${courseSlug}/.learn/sidebar.json`);
                         return res.status(200).json(fixedSidebar);
                     }
-                    await uploadFileToBucket(bucket, JSON.stringify(sidebar), `courses/${courseSlug}/.learn/sidebar.json`);
                     return res.status(200).json(sidebar);
                 }
                 console.error("Unexpected error:", error);
                 res.status(500).json({ error: error.message });
             }
         });
-        // app.get("/test/:slug", (req, res) => {
-        //   emitToCourse(req.params.slug, "course-creation", {
-        //     lesson: "000-welcome-to-bird-domestication",
-        //     status: "generating",
-        //     log: "Hello",
-        //   })
-        //   emitToCourse(req.params.slug, "course-creation", {
-        //     lesson: "000-welcome-to-bird-domestication",
-        //     status: "generating",
-        //     log: "Hello",
-        //   })
-        //   emitToCourse(req.params.slug, "course-creation", {
-        //     lesson: "000-welcome-to-bird-domestication",
-        //     status: "generating",
-        //     log: "Hello broder",
-        //   })
-        //   emitToCourse(req.params.slug, "course-creation", {
-        //     lesson: "000-welcome-to-bird-domestication",
-        //     status: "done",
-        //     log: "Hello broder",
-        //   })
-        //   emitToCourse(req.params.slug, "course-creation", {
-        //     lesson: "other",
-        //     status: "generating",
-        //     log: "Hello",
-        //   })
-        //   res.send({ message: "Course creation started" })
-        // })
         app.get("/technologies", async (req, res) => {
             console.log("GET /technologies");
             const technologies = await api_1.default.getCurrentTechnologies();
@@ -718,7 +778,7 @@ class ServeCommand extends SessionCommand_1.default {
             if (!rigoToken || !bcToken) {
                 return res.status(400).json({ error: "Missing tokens" });
             }
-            const courseSlug = (0, creatorUtilities_2.slugify)(syllabus.courseInfo.title);
+            const courseSlug = syllabus.courseInfo.slug;
             const tutorialDir = `courses/${courseSlug}`;
             const learnJson = (0, exports.createLearnJson)(syllabus.courseInfo);
             try {
@@ -755,9 +815,10 @@ class ServeCommand extends SessionCommand_1.default {
             const firstLesson = syllabus.lessons[0];
             const lastResult = "Nothing";
             await startExerciseGeneration(bucket, rigoToken, syllabus.lessons, syllabus.courseInfo, firstLesson, tutorialDir, courseSlug, syllabus.courseInfo.purpose, lastResult);
+            await createInitialReadme(JSON.stringify(syllabus.courseInfo), courseSlug, rigoToken);
             return res.json({
                 message: "Course created",
-                slug: (0, creatorUtilities_2.slugify)(syllabus.courseInfo.title),
+                slug: syllabus.courseInfo.slug,
             });
         });
         app.get("/courses/:courseSlug/syllabus", async (req, res) => {
@@ -873,11 +934,6 @@ class ServeCommand extends SessionCommand_1.default {
                     title = config.title[availableLangs[0]];
                     selectedLang = availableLangs[0];
                 }
-                console.log(config.description, "CONFIG DESCRIPTION");
-                // console.log(availableLangs, "AVAILABLE LANGs")
-                // console.log(selectedLang, "SELECTED LANG")
-                // console.log(title, "TITLE")
-                // 5) Inyectar placeholders en index.html
                 const idxTpl = fs.readFileSync(path.join(uiSrc, "index.html"), "utf-8");
                 const idxHtml = idxTpl
                     .replace(/{{title}}/g, title)
@@ -920,10 +976,11 @@ class ServeCommand extends SessionCommand_1.default {
                     form.append("file", fs.createReadStream(zipPath));
                     form.append("config", JSON.stringify(config));
                     const rigoRes = await axios_1.default.post(`${api_1.RIGOBOT_HOST}/v1/learnpack/upload`, form, {
-                        headers: Object.assign(Object.assign({}, form.getHeaders()), { Authorization: `Token ${rigoToken}` }),
+                        headers: Object.assign(Object.assign({}, form.getHeaders()), { Authorization: `Token ${rigoToken.trim()}` }),
                     });
-                    await (0, publish_1.handleAssetCreation)({ token: bcToken, rigobotToken: rigoToken }, fullConfig.config, selectedLang, rigoRes.data.url);
+                    await createMultiLangAsset(bucket, rigoToken, bcToken, slug, fullConfig.config, rigoRes.data.url);
                     rimraf.sync(tmpRoot);
+                    console.log("RigoRes", rigoRes.data);
                     return res.json({ url: rigoRes.data.url });
                 });
                 archive.on("error", err => {