@learnpack/learnpack 5.0.320 → 5.0.322

package/lib/commands/serve.js

@@ -32,6 +32,7 @@ const creatorUtilities_2 = require("../utils/creatorUtilities");
 const sidebarGenerator_1 = require("../utils/sidebarGenerator");
 const publish_1 = require("./publish");
 const export_1 = require("../utils/export");
+const errorHandler_1 = require("../utils/errorHandler");
 const frontMatter = require("front-matter");
 if (process.env.NEW_RELIC_ENABLED === "true") {
     require("newrelic");
@@ -182,6 +183,13 @@ const lessonCleaner = (lesson) => {
     return Object.assign(Object.assign({}, lesson), { duration: undefined, generated: undefined, status: undefined, translations: undefined, uid: undefined, initialContent: undefined, locked: undefined });
 };
 async function startInitialContentGeneration(rigoToken, steps, packageContext, exercise, courseSlug, purposeSlug, lastLesson = "") {
+    // Defensive validation
+    if (!exercise) {
+        throw new errorHandler_1.ValidationError("Exercise is required but was not provided");
+    }
+    if (!exercise.id || !exercise.title) {
+        throw new errorHandler_1.ValidationError(`Exercise is missing required properties: id=${exercise.id}, title=${exercise.title}`);
+    }
     const exSlug = (0, creatorUtilities_2.slugify)(exercise.id + "-" + exercise.title);
     console.log("Starting initial content generation for", exSlug);
     const webhookUrl = `${process.env.HOST}/webhooks/${courseSlug}/initial-content-processor/${exercise.uid}/${rigoToken}`;
@@ -649,9 +657,8 @@ class ServeCommand extends SessionCommand_1.default {
                             return res.status(404).json({ error: "Exercise not found" });
                         }
                         const exerciseDir = `courses/${courseSlug}/exercises/${exercise.slug}`;
-                        for (const fileStr of files) {
+                        for (const fileObj of files) {
                             try {
-                                const fileObj = JSON.parse(fileStr);
                                 console.log(`📄 Processing file: ${fileObj.name}`);
                                 // Save the main file with content
                                 if (fileObj.name && fileObj.content) {
@@ -696,7 +703,7 @@ class ServeCommand extends SessionCommand_1.default {
                 res.status(500).json({ error: error.message });
             }
         });
-        app.post("/actions/continue-generating/:courseSlug/:lessonUid", async (req, res) => {
+        app.post("/actions/continue-generating/:courseSlug/:lessonUid", (0, errorHandler_1.asyncHandler)(async (req, res) => {
             const { courseSlug, lessonUid } = req.params;
             const { feedback, mode } = req.body;
             const rigoToken = req.header("x-rigo-token");
@@ -706,13 +713,23 @@ class ServeCommand extends SessionCommand_1.default {
             // console.log("FEEDBACK", feedback);
             // console.log("MODE", mode);
             if (!rigoToken) {
-                return res.status(400).json({
-                    error: "Rigo token is required. x-rigo-token header is missing",
-                });
+                throw new errorHandler_1.ValidationError("Rigo token is required. x-rigo-token header is missing");
             }
             const syllabus = await getSyllabus(courseSlug, bucket);
             const exercise = syllabus.lessons.find(lesson => lesson.uid === lessonUid);
             const exerciseIndex = syllabus.lessons.findIndex(lesson => lesson.uid === lessonUid);
+            // Validate that exercise exists
+            if (!exercise) {
+                throw new errorHandler_1.NotFoundError(`Lesson with UID "${lessonUid}" not found in course "${courseSlug}"`);
+            }
+            // Validate that exercise index is valid (defensive check)
+            if (exerciseIndex === -1) {
+                throw new errorHandler_1.NotFoundError(`Lesson with UID "${lessonUid}" not found in course "${courseSlug}"`);
+            }
+            // Validate that exercise has required properties
+            if (!exercise.id || !exercise.title) {
+                throw new errorHandler_1.ValidationError(`Lesson "${lessonUid}" is missing required properties (id or title)`);
+            }
             // previous exercise
             let previousReadme = "---";
             const previousExercise = syllabus.lessons[exerciseIndex - 1];
@@ -753,7 +770,7 @@ class ServeCommand extends SessionCommand_1.default {
             syllabus.generationMode = mode;
             await saveSyllabus(courseSlug, syllabus, bucket);
             res.json({ status: "SUCCESS" });
-        });
+        }));
         // TODO: Check if this command is being used
         app.post("/actions/generate-image/:courseSlug", async (req, res) => {
             const rigoToken = req.header("x-rigo-token");
@@ -1383,22 +1400,49 @@ class ServeCommand extends SessionCommand_1.default {
             res.set("Content-Disposition", `attachment; filename="${file}"`);
             fileStream.pipe(res);
         });
-        app.put("/exercise/:slug/file/:fileName", express.text(), async (req, res) => {
+        app.put("/exercise/:slug/file/:fileName", express.text(), (0, errorHandler_1.asyncHandler)(async (req, res) => {
+            var _a, _b;
             const { slug, fileName } = req.params;
             const query = req.query;
-            console.log(`PUT /exercise/${slug}/file/${fileName}`);
             const courseSlug = query.slug;
-            // console.log("COURSE SLUG", courseSlug)
-            // Update the file in the bucket
-            const file = await bucket.file(`courses/${courseSlug}/exercises/${slug}/${fileName}`);
-            await file.save(req.body);
-            const created = await file.exists();
-            // console.log("File updated", created)
-            res.send({
-                message: "File updated",
-                created,
-            });
-        });
+            console.log(`PUT /exercise/${slug}/file/${fileName}`);
+            // Validate required parameters
+            if (!courseSlug) {
+                throw new errorHandler_1.ValidationError("Course slug is required in query parameters");
+            }
+            if (!fileName || !slug) {
+                throw new errorHandler_1.ValidationError("File name and exercise slug are required");
+            }
+            try {
+                // Update the file in the bucket
+                const file = bucket.file(`courses/${courseSlug}/exercises/${slug}/${fileName}`);
+                await file.save(req.body, {
+                    resumable: false,
+                });
+                const created = await file.exists();
+                res.send({
+                    message: "File updated",
+                    created,
+                });
+            }
+            catch (error) {
+                // Handle Google Cloud Storage rate limit errors (429)
+                if (error.code === 429 ||
+                    ((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes("rate limit")) ||
+                    ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes("rateLimitExceeded"))) {
+                    throw new errorHandler_1.ConflictError("Storage rate limit exceeded. Please try again in a few moments.", {
+                        code: "STORAGE_RATE_LIMIT",
+                        retryAfter: 60, // seconds
+                    });
+                }
+                // Handle other GCS errors
+                if (error.code) {
+                    throw new errorHandler_1.InternalServerError(`Storage error: ${error.message || "Failed to update file"}`, { code: error.code });
+                }
+                // Re-throw if it's already an operational error
+                throw error;
+            }
+        }));
         // Create a new step for a course
         app.post("/course/:slug/create-step", async (req, res) => {
             console.log("POST /course/:slug/create-step");
@@ -2393,6 +2437,10 @@ class ServeCommand extends SessionCommand_1.default {
                     .json({ error: "Export failed", details: error.message });
             }
         });
+        // 404 error handler
+        app.use(errorHandler_1.notFoundHandler);
+        // Global error handler
+        app.use(errorHandler_1.errorHandler);
         server.listen(PORT, () => {
             console.log(`🚀 Creator UI server running at http://localhost:${PORT}/creator`);
         });

package/lib/utils/checkNotInstalled.d.ts

@@ -4,5 +4,5 @@ type TNeededPlugins = {
     notInstalled: string[];
 };
 export declare const checkNotInstalledPlugins: (exercises: IExercise[], installedPlugins: string[], command: any) => Promise<TNeededPlugins>;
-export declare const checkNotInstalledDependencies: (neededPlugins: string[]) => Promise<boolean | undefined>;
+export declare const checkNotInstalledDependencies: (neededPlugins: string[]) => Promise<boolean>;
 export {};

package/lib/utils/checkNotInstalled.js

@@ -114,18 +114,47 @@ const installDependencies = async (deps, packageManager) => {
     else if (packageManager === "pip") {
         command = `pip install ${deps.join(" ")}`;
     }
-    const { stdout, stderr } = await exec(command);
-    if (stderr && (stderr.includes("npm ERR!") || stderr.includes("Traceback"))) {
-        console_1.default.error(`Error executing ${command}.`);
-        console_1.default.error(stderr);
-        return;
+    try {
+        const { stdout, stderr } = await exec(command);
+        if (stderr &&
+            (stderr.includes("npm ERR!") || stderr.includes("Traceback"))) {
+            console_1.default.error(`Error executing ${command}.`);
+            console_1.default.error(stderr);
+            return;
+        }
+        console_1.default.info(`Dependencies ${deps.join(" ")} installed...`);
+        return true;
+    }
+    catch (error) {
+        // Si npm/pip retorna código > 0, exec lanzará una excepción
+        const execError = error;
+        const stdout = execError.stdout || "";
+        const stderr = execError.stderr || "";
+        const errorMessage = stderr || execError.message || String(error);
+        // Verificar si es un error real
+        if (errorMessage.includes("npm ERR!") ||
+            errorMessage.includes("Traceback")) {
+            console_1.default.error(`Error executing ${command}.`);
+            console_1.default.error(errorMessage);
+            return;
+        }
+        // Si no es un error real, podría ser solo un warning
+        // Verificar si la instalación fue exitosa a pesar del warning
+        if (stdout &&
+            (stdout.includes("added") || stdout.includes("Successfully installed"))) {
+            console_1.default.info(`Dependencies ${deps.join(" ")} installed...`);
+            return true;
+        }
+        // Si no hay indicios de éxito, se asume fallo (retorna undefined implícitamente)
+        console_1.default.debug(`${command} returned non-zero exit code, but may be just a warning:`, errorMessage);
     }
-    console_1.default.info(`Dependencies ${deps.join(" ")} installed...`);
-    return true;
 };
 const checkNotInstalledDependencies = async (neededPlugins) => {
     console_1.default.info("Checking needed dependencies...");
-    const jsPluginsDependencies = ["jest@29.7.0", "jest-environment-jsdom@29.7.0"];
+    const jsPluginsDependencies = [
+        "jest@29.7.0",
+        "jest-environment-jsdom@29.7.0",
+    ];
     // pytest up to 6.2.5
     const pyPluginsDependencies = ["pytest", "pytest-testdox", "mock"];
     const npmLsCommand = "npm ls jest jest-environment-jsdom -g";
@@ -141,14 +170,29 @@ const checkNotInstalledDependencies = async (neededPlugins) => {
         pytestNeeded = true;
     }
     if (jestNeeded) {
-        const { stdout, stderr } = await exec("npm ls -g");
-        if (stderr) {
-            console_1.default.error(`Error executing ${npmLsCommand}. Use debug for more info`);
-            console_1.default.debug(stderr);
-            return false;
+        try {
+            const { stdout, stderr } = await exec("npm ls -g");
+            // Solo considerar errores reales, no warnings
+            if (stderr && stderr.includes("npm ERR!")) {
+                console_1.default.error(`Error executing npm ls -g. Use debug for more info`);
+                console_1.default.debug(stderr);
+                return false;
+            }
+            if (includesAll(stdout, jsPluginsDependencies))
+                return true;
+        }
+        catch (error) {
+            // Si npm retorna código > 0, exec lanzará una excepción
+            // Verificar si es un error real o solo un warning
+            const errorMessage = (error === null || error === void 0 ? void 0 : error.stderr) || (error === null || error === void 0 ? void 0 : error.message) || String(error);
+            if (errorMessage.includes("npm ERR!")) {
+                console_1.default.error(`Error executing npm ls -g. Use debug for more info`);
+                console_1.default.debug(errorMessage);
+                return false;
+            }
+            // Si no es un error real, continuar (podría ser solo un warning)
+            console_1.default.debug("npm ls -g returned non-zero exit code, but may be just a warning:", errorMessage);
         }
-        if (includesAll(stdout, jsPluginsDependencies))
-            return true;
         console_1.default.error("The jest dependencies are not installed");
         const confirmInstall = await cli_ux_1.cli.confirm("Do you want to install the needed dependencies? (y/n)");
         if (!confirmInstall) {
@@ -167,14 +211,28 @@ const checkNotInstalledDependencies = async (neededPlugins) => {
             console_1.default.error("Error upgrading pip. Please install pip manually, run: pip install --upgrade pip");
             console_1.default.debug(error);
         }
-        const { stdout, stderr } = await exec("pip list");
-        if (stderr) {
-            console_1.default.error(`Error executing pip list. Use debug for more info`);
-            console_1.default.debug(stderr);
-            return;
+        try {
+            const { stdout, stderr } = await exec("pip list");
+            // Solo considerar errores reales, no warnings
+            if (stderr && stderr.includes("Traceback")) {
+                console_1.default.error(`Error executing pip list. Use debug for more info`);
+                console_1.default.debug(stderr);
+                return false;
+            }
+            if (includesAll(stdout, pyPluginsDependencies))
+                return true;
+        }
+        catch (error) {
+            // Si pip retorna código > 0, verificar si es un error real
+            const errorMessage = (error === null || error === void 0 ? void 0 : error.stderr) || (error === null || error === void 0 ? void 0 : error.message) || String(error);
+            if (errorMessage.includes("Traceback")) {
+                console_1.default.error(`Error executing pip list. Use debug for more info`);
+                console_1.default.debug(errorMessage);
+                return false;
+            }
+            // Si no es un error real, continuar
+            console_1.default.debug("pip list returned non-zero exit code, but may be just a warning:", errorMessage);
         }
-        if (includesAll(stdout, pyPluginsDependencies))
-            return true;
         console_1.default.error("The pytest dependencies are not installed");
         const confirmInstall = await cli_ux_1.cli.confirm("Do you want to install the needed dependencies? (y/n)");
         if (!confirmInstall) {

package/lib/utils/errorHandler.d.ts

@@ -0,0 +1,97 @@
+import { Request, Response, NextFunction } from "express";
+/**
+ * Interface for application errors with additional information
+ */
+export interface AppError extends Error {
+    statusCode?: number;
+    code?: string;
+    isOperational?: boolean;
+    details?: any;
+}
+/**
+ * Base class for operational errors (expected errors)
+ */
+export declare class OperationalError extends Error implements AppError {
+    statusCode: number;
+    code: string;
+    isOperational: boolean;
+    details?: any;
+    constructor(message: string, details?: any, statusCode?: number, code?: string);
+}
+/**
+ * Validation error (400)
+ */
+export declare class ValidationError extends OperationalError {
+    constructor(message: string, details?: any);
+}
+/**
+ * Authentication error (401)
+ */
+export declare class UnauthorizedError extends OperationalError {
+    constructor(message: string, details?: any);
+}
+/**
+ * Authorization error (403)
+ */
+export declare class ForbiddenError extends OperationalError {
+    constructor(message: string, details?: any);
+}
+/**
+ * Resource not found error (404)
+ */
+export declare class NotFoundError extends OperationalError {
+    constructor(message: string, details?: any);
+}
+/**
+ * Conflict error (409)
+ */
+export declare class ConflictError extends OperationalError {
+    constructor(message: string, details?: any);
+}
+/**
+ * Internal server error (500)
+ */
+export declare class InternalServerError extends OperationalError {
+    constructor(message: string, details?: any);
+}
+/**
+ * Wrapper for async handlers that automatically catches errors
+ *
+ * Usage:
+ * app.get('/route', asyncHandler(async (req, res) => {
+ *   // your async code here
+ * }))
+ * @param fn - Async handler function to wrap
+ * @returns Express middleware that automatically catches errors
+ */
+export declare const asyncHandler: (fn: (req: Request, res: Response, next: NextFunction) => Promise<any>) => (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Middleware to handle not found routes (404)
+ * Must be placed after all routes but before the error handler
+ * @param req - Express Request object
+ * @param res - Express Response object
+ * @param next - Express next function
+ * @returns void
+ */
+export declare const notFoundHandler: (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Global error handling middleware
+ * Must be the last middleware in the chain
+ *
+ * Catches all unhandled synchronous and asynchronous errors
+ * @param error - The caught error
+ * @param req - Express Request object
+ * @param res - Express Response object
+ * @param next - Express next function
+ * @returns void
+ */
+export declare const errorHandler: (error: AppError | Error, req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Helper to quickly create operational errors
+ * @param message - Error message
+ * @param details - Additional error details
+ * @param statusCode - HTTP status code
+ * @param code - Custom error code
+ * @returns New OperationalError instance
+ */
+export declare const createError: (message: string, details?: any, statusCode?: number, code?: string) => OperationalError;

package/lib/utils/errorHandler.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createError = exports.errorHandler = exports.notFoundHandler = exports.asyncHandler = exports.InternalServerError = exports.ConflictError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.ValidationError = exports.OperationalError = void 0;
+/**
+ * Base class for operational errors (expected errors)
+ */
+class OperationalError extends Error {
+    constructor(message, details, statusCode = 500, code = "OPERATIONAL_ERROR") {
+        super(message);
+        this.name = this.constructor.name;
+        this.statusCode = statusCode;
+        this.code = code;
+        this.isOperational = true;
+        this.details = details;
+        // Maintains correct stack trace
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.OperationalError = OperationalError;
+/**
+ * Validation error (400)
+ */
+class ValidationError extends OperationalError {
+    constructor(message, details) {
+        super(message, details, 400, "VALIDATION_ERROR");
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * Authentication error (401)
+ */
+class UnauthorizedError extends OperationalError {
+    constructor(message, details) {
+        super(message, details, 401, "UNAUTHORIZED");
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+/**
+ * Authorization error (403)
+ */
+class ForbiddenError extends OperationalError {
+    constructor(message, details) {
+        super(message, details, 403, "FORBIDDEN");
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+/**
+ * Resource not found error (404)
+ */
+class NotFoundError extends OperationalError {
+    constructor(message, details) {
+        super(message, details, 404, "NOT_FOUND");
+    }
+}
+exports.NotFoundError = NotFoundError;
+/**
+ * Conflict error (409)
+ */
+class ConflictError extends OperationalError {
+    constructor(message, details) {
+        super(message, details, 409, "CONFLICT");
+    }
+}
+exports.ConflictError = ConflictError;
+/**
+ * Internal server error (500)
+ */
+class InternalServerError extends OperationalError {
+    constructor(message, details) {
+        super(message, details, 500, "INTERNAL_SERVER_ERROR");
+    }
+}
+exports.InternalServerError = InternalServerError;
+/**
+ * Determines if an error is operational (expected) or programming (unexpected)
+ * @param error - The error to check
+ * @returns true if the error is operational, false otherwise
+ */
+function isOperationalError(error) {
+    if (error instanceof OperationalError) {
+        return error.isOperational === true;
+    }
+    return false;
+}
+/**
+ * Formats the error for HTTP response
+ * @param error - The error to format
+ * @param isDevelopment - Whether in development mode
+ * @returns Object with the formatted response
+ */
+function formatError(error, isDevelopment = false) {
+    const isOperational = isOperationalError(error);
+    const appError = error;
+    const baseResponse = {
+        status: "error",
+        message: appError.message || "An unexpected error occurred",
+        code: appError.code || "INTERNAL_ERROR",
+    };
+    // In development, include more details
+    if (isDevelopment) {
+        baseResponse.stack = appError.stack;
+        baseResponse.details = appError.details;
+    }
+    // If it's an operational error, include details if they exist
+    if (isOperational && appError.details) {
+        baseResponse.details = appError.details;
+    }
+    // If not operational, don't expose details in production
+    if (!isOperational && !isDevelopment) {
+        baseResponse.message = "An unexpected error occurred";
+        baseResponse.code = "INTERNAL_ERROR";
+    }
+    return baseResponse;
+}
+/**
+ * Determines the appropriate HTTP status code
+ * @param error - The error from which to get the status code
+ * @returns The HTTP status code
+ */
+function getStatusCode(error) {
+    if (error.statusCode) {
+        return error.statusCode;
+    }
+    // Common Node.js errors
+    if (error.name === "ValidationError")
+        return 400;
+    if (error.name === "UnauthorizedError")
+        return 401;
+    if (error.name === "ForbiddenError")
+        return 403;
+    if (error.name === "NotFoundError")
+        return 404;
+    if (error.name === "ConflictError")
+        return 409;
+    // Default to server error
+    return 500;
+}
+/**
+ * Logs the error in a structured format
+ * @param error - The error to log
+ * @param req - Express Request object
+ * @returns void
+ */
+function logError(error, req) {
+    const appError = error;
+    const isOperational = isOperationalError(error);
+    const logData = {
+        timestamp: new Date().toISOString(),
+        method: req.method,
+        url: req.originalUrl,
+        statusCode: getStatusCode(error),
+        error: {
+            name: error.name,
+            message: error.message,
+            code: appError.code,
+            isOperational,
+            stack: error.stack,
+            details: appError.details,
+        },
+        ip: req.ip || req.socket.remoteAddress,
+        userAgent: req.get("user-agent"),
+    };
+    // Different log based on error type
+    if (isOperational) {
+        console.error("⚠️  Operational Error:", JSON.stringify(logData, null, 2));
+    }
+    else {
+        console.error("❌ Unexpected Error:", JSON.stringify(logData, null, 2));
+    }
+}
+/**
+ * Wrapper for async handlers that automatically catches errors
+ *
+ * Usage:
+ * app.get('/route', asyncHandler(async (req, res) => {
+ *   // your async code here
+ * }))
+ * @param fn - Async handler function to wrap
+ * @returns Express middleware that automatically catches errors
+ */
+const asyncHandler = (fn) => {
+    return (req, res, next) => {
+        Promise.resolve(fn(req, res, next)).catch(next);
+    };
+};
+exports.asyncHandler = asyncHandler;
+/**
+ * Middleware to handle not found routes (404)
+ * Must be placed after all routes but before the error handler
+ * @param req - Express Request object
+ * @param res - Express Response object
+ * @param next - Express next function
+ * @returns void
+ */
+const notFoundHandler = (req, res, next) => {
+    const error = new NotFoundError(`Route ${req.method} ${req.originalUrl} not found`);
+    next(error);
+};
+exports.notFoundHandler = notFoundHandler;
+/**
+ * Global error handling middleware
+ * Must be the last middleware in the chain
+ *
+ * Catches all unhandled synchronous and asynchronous errors
+ * @param error - The caught error
+ * @param req - Express Request object
+ * @param res - Express Response object
+ * @param next - Express next function
+ * @returns void
+ */
+const errorHandler = (error, req, res, next) => {
+    // If response already sent, delegate to Express default handler
+    if (res.headersSent) {
+        return next(error);
+    }
+    // Determine if we're in development mode
+    const isDevelopment = process.env.NODE_ENV === "development" || process.env.DEBUG === "true";
+    // Log the error
+    logError(error, req);
+    // Get status code
+    const statusCode = getStatusCode(error);
+    // Format response
+    const response = formatError(error, isDevelopment);
+    // Send response
+    res.status(statusCode).json(response);
+};
+exports.errorHandler = errorHandler;
+/**
+ * Helper to quickly create operational errors
+ * @param message - Error message
+ * @param details - Additional error details
+ * @param statusCode - HTTP status code
+ * @param code - Custom error code
+ * @returns New OperationalError instance
+ */
+const createError = (message, details, statusCode, code) => {
+    return new OperationalError(message, details, statusCode || 500, code || "OPERATIONAL_ERROR");
+};
+exports.createError = createError;

package/lib/utils/rigoActions.js

@@ -327,7 +327,7 @@ const addInteractivity = async (token, inputs, webhookUrl) => {
 exports.addInteractivity = addInteractivity;
 const generateCodeChallenge = async (token, inputs, webhookUrl) => {
     try {
-        const response = await axios_1.default.post(`${api_1.RIGOBOT_HOST}/v1/prompting/completion/generate-code-challenge-files/`, {
+        const response = await axios_1.default.post(`${api_1.RIGOBOT_HOST}/v1/prompting/completion/create-structured-coding-filles/`, {
             inputs,
             include_purpose_objective: false,
             execute_async: !!webhookUrl,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@learnpack/learnpack",
   "description": "Seamlessly build, sell and/or take interactive & auto-graded tutorials, start learning now or build a new tutorial to your audience.",
-  "version": "5.0.320",
+  "version": "5.0.322",
   "author": "Alejandro Sanchez @alesanchezr",
   "contributors": [
     {