@learnpack/learnpack 5.0.328 → 5.0.331

package/lib/managers/historyManager.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryManager = void 0;
+const fs = require("fs");
+const path = require("path");
+class HistoryManager {
+    constructor(redisClient) {
+        this.TTL = "432000"; // 5 days in seconds
+        this.LIMIT = 5; // Keep last 5 states
+        this.redis = redisClient;
+        // Load Lua scripts
+        const luaDir = path.join(__dirname, "../lua");
+        this.saveStateLua = fs.readFileSync(path.join(luaDir, "saveState.lua"), "utf8");
+        this.undoLua = fs.readFileSync(path.join(luaDir, "undo.lua"), "utf8");
+        this.redoLua = fs.readFileSync(path.join(luaDir, "redo.lua"), "utf8");
+    }
+    /**
+     * Builds Redis keys for an exercise in a specific language
+     * @param courseSlug - The course slug identifier
+     * @param exerciseSlug - The exercise slug identifier
+     * @param lang - The language code
+     * @returns Object containing undo, redo, and version keys
+     */
+    getKeys(courseSlug, exerciseSlug, lang) {
+        const baseKey = `${courseSlug}:${exerciseSlug}:${lang}`;
+        return {
+            undo: `undo:${baseKey}`,
+            redo: `redo:${baseKey}`,
+            version: `undo:${baseKey}:version`,
+        };
+    }
+    /**
+     * Saves a new state in history
+     * @param courseSlug - The course slug identifier
+     * @param exerciseSlug - The exercise slug identifier
+     * @param lang - The language code
+     * @param content - The content of the state
+     * @param versionId - The version ID
+     * @returns Object containing success, newVersion, and error
+     */
+    async saveState(courseSlug, exerciseSlug, lang, content, versionId) {
+        const keys = this.getKeys(courseSlug, exerciseSlug, lang);
+        const state = {
+            content,
+            timestamp: Date.now(),
+        };
+        const stateJson = JSON.stringify(state);
+        try {
+            // Official Redis client syntax: eval(script, { keys: [...], arguments: [...] })
+            const result = await this.redis.eval(this.saveStateLua, {
+                keys: [keys.undo, keys.redo, keys.version],
+                arguments: [
+                    stateJson,
+                    versionId,
+                    this.TTL.toString(),
+                    this.LIMIT.toString(),
+                ],
+            });
+            // Check if it's an error response (table with err field)
+            if (result && typeof result === "object" && result.err) {
+                return { success: false, error: result.err };
+            }
+            // Success response is a string (the new version)
+            const newVersion = typeof result === "string" ? result : String(result);
+            return { success: true, newVersion };
+        }
+        catch (error) {
+            console.error("⏮️  HISTORY: Error saving state to Redis:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Performs an undo operation
+     * @param courseSlug - The course slug identifier
+     * @param exerciseSlug - The exercise slug identifier
+     * @param lang - The language code
+     * @param currentContent - The current content of the state
+     * @param versionId - The version ID
+     * @returns Object containing success, newVersion, and error
+     */
+    async undo(courseSlug, exerciseSlug, lang, currentContent, versionId) {
+        const keys = this.getKeys(courseSlug, exerciseSlug, lang);
+        const currentState = {
+            content: currentContent,
+            timestamp: Date.now(),
+        };
+        try {
+            const result = await this.redis.eval(this.undoLua, {
+                keys: [keys.undo, keys.redo, keys.version],
+                arguments: [
+                    JSON.stringify(currentState),
+                    versionId,
+                    this.TTL.toString(),
+                ],
+            });
+            // Check if it's an error response (table with err field)
+            if (result && typeof result === "object" && result.err) {
+                return { success: false, error: result.err };
+            }
+            // Success response is an array: [newVersion, previousState]
+            if (!Array.isArray(result) || result.length < 2) {
+                console.error("⏮️  HISTORY: Invalid response from undo script:", result);
+                return { success: false, error: "INVALID_RESPONSE" };
+            }
+            const [newVersion, previousStateJson] = result;
+            if (!previousStateJson) {
+                console.error("⏮️  HISTORY: No state returned from undo script");
+                return { success: false, error: "NO_STATE_RETURNED" };
+            }
+            const previousState = JSON.parse(previousStateJson);
+            return {
+                success: true,
+                newVersion: String(newVersion),
+                content: previousState.content,
+            };
+        }
+        catch (error) {
+            console.error("⏮️  HISTORY: Error performing undo:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Performs a redo operation
+     * @param courseSlug - The course slug identifier
+     * @param exerciseSlug - The exercise slug identifier
+     * @param lang - The language code
+     * @param currentContent - The current content of the state
+     * @param versionId - The version ID
+     * @returns Object containing success, newVersion, and error
+     */
+    async redo(courseSlug, exerciseSlug, lang, currentContent, versionId) {
+        const keys = this.getKeys(courseSlug, exerciseSlug, lang);
+        const currentState = {
+            content: currentContent,
+            timestamp: Date.now(),
+        };
+        try {
+            const result = await this.redis.eval(this.redoLua, {
+                keys: [keys.undo, keys.redo, keys.version],
+                arguments: [
+                    JSON.stringify(currentState),
+                    versionId,
+                    this.TTL.toString(),
+                ],
+            });
+            // Check if it's an error response (table with err field)
+            if (result && typeof result === "object" && result.err) {
+                return { success: false, error: result.err };
+            }
+            // Success response is an array: [newVersion, futureState]
+            if (!Array.isArray(result) || result.length < 2) {
+                console.error("⏮️  HISTORY: Invalid response from redo script:", result);
+                return { success: false, error: "INVALID_RESPONSE" };
+            }
+            const [newVersion, futureStateJson] = result;
+            if (!futureStateJson) {
+                console.error("⏮️  HISTORY: No state returned from redo script");
+                return { success: false, error: "NO_STATE_RETURNED" };
+            }
+            const futureState = JSON.parse(futureStateJson);
+            return {
+                success: true,
+                newVersion: String(newVersion),
+                content: futureState.content,
+            };
+        }
+        catch (error) {
+            console.error("⏮️  HISTORY: Error performing redo:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Gets the history status (can undo/redo, current version)
+     * @param courseSlug - The course slug identifier
+     * @param exerciseSlug - The exercise slug identifier
+     * @param lang - The language code
+     * @returns Object containing canUndo, canRedo, and version
+     */
+    async getHistoryStatus(courseSlug, exerciseSlug, lang) {
+        const keys = this.getKeys(courseSlug, exerciseSlug, lang);
+        try {
+            const [undoLen, redoLen, version] = await Promise.all([
+                this.redis.lLen(keys.undo),
+                this.redis.lLen(keys.redo),
+                this.redis.get(keys.version),
+            ]);
+            return {
+                canUndo: undoLen >= 1, // Need at least 1 (we save state BEFORE changes)
+                canRedo: redoLen > 0,
+                version: version || "0",
+            };
+        }
+        catch (error) {
+            console.error("⏮️  HISTORY: Error getting history status:", error);
+            return {
+                canUndo: false,
+                canRedo: false,
+                version: "0",
+            };
+        }
+    }
+}
+exports.HistoryManager = HistoryManager;

package/lib/managers/readmeHistoryService.d.ts

@@ -0,0 +1,76 @@
+import type { Bucket } from "@google-cloud/storage";
+import type { HistoryManager } from "./historyManager";
+export interface SaveReadmeWithHistoryOptions {
+    courseSlug: string;
+    exerciseSlug: string;
+    lang: string;
+    fileName: string;
+    newContent: string;
+    previousContent?: string;
+    currentVersion?: string;
+    throwOnConflict?: boolean;
+}
+export interface SaveReadmeResult {
+    success: boolean;
+    newVersion: string;
+    error?: string;
+}
+/**
+ * Service to handle README file updates with automatic history tracking
+ * Encapsulates the logic of saving state to history before updating files
+ */
+export declare class ReadmeHistoryService {
+    private historyManager;
+    private bucket;
+    /**
+     * Constructor for the ReadmeHistoryService
+     * @param historyManager - The history manager to use
+     * @param bucket - The bucket to use
+     */
+    constructor(historyManager: HistoryManager | null, bucket: Bucket);
+    /**
+     * Saves a README file to GCS with automatic history tracking
+     *
+     * Workflow:
+     * 1. If previousContent is not provided, downloads it from GCS
+     * 2. If currentVersion is not provided, gets it from history
+     * 3. Saves the PREVIOUS state to history (for undo)
+     * 4. Saves the NEW content to GCS
+     *
+     * @param options - Options for the saveReadmeWithHistory method
+     * @returns Result with success status and new version
+     */
+    saveReadmeWithHistory(options: SaveReadmeWithHistoryOptions): Promise<SaveReadmeResult>;
+    /**
+     * Gets the previous content of a README from GCS
+     * Returns undefined if file doesn't exist (first version)
+     * @param courseSlug - The slug of the course
+     * @param exerciseSlug - The slug of the exercise
+     * @param fileName - The name of the file
+     * @returns The previous content of the file or undefined if it doesn't exist
+     */
+    private getPreviousContent;
+    /**
+     * Gets the current version from history
+     * @param courseSlug - The slug of the course
+     * @param exerciseSlug - The slug of the exercise
+     * @param lang - The language of the file
+     * @returns The current version of the file
+     */
+    private getCurrentVersion;
+    /**
+     * Saves content to Google Cloud Storage
+     * @param courseSlug - The slug of the course
+     * @param exerciseSlug - The slug of the exercise
+     * @param fileName - The name of the file
+     * @param content - The content to save
+     * @returns void
+     */
+    private saveToGCS;
+    /**
+     * Helper to get README extension from language code
+     * @param lang - The language of the file
+     * @returns The name of the README file
+     */
+    static getReadmeFileName(lang: string): string;
+}

package/lib/managers/readmeHistoryService.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadmeHistoryService = void 0;
+/**
+ * Service to handle README file updates with automatic history tracking
+ * Encapsulates the logic of saving state to history before updating files
+ */
+class ReadmeHistoryService {
+    /**
+     * Constructor for the ReadmeHistoryService
+     * @param historyManager - The history manager to use
+     * @param bucket - The bucket to use
+     */
+    constructor(historyManager, bucket) {
+        this.historyManager = historyManager;
+        this.bucket = bucket;
+    }
+    /**
+     * Saves a README file to GCS with automatic history tracking
+     *
+     * Workflow:
+     * 1. If previousContent is not provided, downloads it from GCS
+     * 2. If currentVersion is not provided, gets it from history
+     * 3. Saves the PREVIOUS state to history (for undo)
+     * 4. Saves the NEW content to GCS
+     *
+     * @param options - Options for the saveReadmeWithHistory method
+     * @returns Result with success status and new version
+     */
+    async saveReadmeWithHistory(options) {
+        const { courseSlug, exerciseSlug, lang, fileName, newContent, previousContent: providedPreviousContent, currentVersion: providedVersion, throwOnConflict = false, } = options;
+        // Guard: Only process README files
+        if (!fileName.startsWith("README")) {
+            console.warn(`⚠️ ReadmeHistoryService called for non-README file: ${fileName}`);
+            return { success: false, newVersion: "0", error: "NOT_README_FILE" };
+        }
+        // Guard: History manager not available
+        if (!this.historyManager) {
+            console.warn("⚠️ History manager not available, skipping history");
+            // Still save the file without history
+            await this.saveToGCS(courseSlug, exerciseSlug, fileName, newContent);
+            return {
+                success: false,
+                newVersion: "0",
+                error: "HISTORY_NOT_AVAILABLE",
+            };
+        }
+        try {
+            // Step 1: Get previous content if not provided
+            const previousContent = providedPreviousContent !== null && providedPreviousContent !== void 0 ? providedPreviousContent : (await this.getPreviousContent(courseSlug, exerciseSlug, fileName));
+            // If there's no previous content, we can't save to history
+            // (this is the first version of the file)
+            if (!previousContent) {
+                console.log(`📝 HISTORY: First version of ${fileName} for ${lang}, skipping history`);
+                await this.saveToGCS(courseSlug, exerciseSlug, fileName, newContent);
+                return {
+                    success: false,
+                    newVersion: "0",
+                    error: "NO_PREVIOUS_CONTENT",
+                };
+            }
+            // Step 2: Get current version if not provided
+            const currentVersion = providedVersion !== null && providedVersion !== void 0 ? providedVersion : (await this.getCurrentVersion(courseSlug, exerciseSlug, lang));
+            // Step 3: Save to history BEFORE updating the file
+            const historyResult = await this.historyManager.saveState(courseSlug, exerciseSlug, lang, previousContent, // Save the content BEFORE the change
+            currentVersion);
+            // Step 4: Handle history save result
+            if (!historyResult.success) {
+                // VERSION_CONFLICT: Another user/process modified the file
+                if (historyResult.error === "VERSION_CONFLICT") {
+                    const message = "Version conflict detected. Content may have been modified by another process.";
+                    if (throwOnConflict) {
+                        throw new Error(message);
+                    }
+                    else {
+                        console.error(`⏮️  HISTORY: ${message}`);
+                        // Still save the file despite conflict
+                        await this.saveToGCS(courseSlug, exerciseSlug, fileName, newContent);
+                        return {
+                            success: false,
+                            newVersion: currentVersion,
+                            error: "VERSION_CONFLICT",
+                        };
+                    }
+                }
+                // Other errors: log but don't fail
+                console.error(`⏮️  HISTORY: Failed to save history (non-critical): ${historyResult.error}`);
+                await this.saveToGCS(courseSlug, exerciseSlug, fileName, newContent);
+                return {
+                    success: false,
+                    newVersion: currentVersion,
+                    error: historyResult.error,
+                };
+            }
+            // Step 5: History saved successfully, now save the new content
+            await this.saveToGCS(courseSlug, exerciseSlug, fileName, newContent);
+            console.log(`✅ HISTORY: Saved ${fileName} (${lang}) - version ${historyResult.newVersion}`);
+            return {
+                success: true,
+                newVersion: historyResult.newVersion,
+            };
+        }
+        catch (error) {
+            const errorMessage = error.message || "Unknown error";
+            console.error(`❌ HISTORY: Error in saveReadmeWithHistory: ${errorMessage}`);
+            // Try to save the file anyway (best effort)
+            try {
+                await this.saveToGCS(courseSlug, exerciseSlug, fileName, newContent);
+            }
+            catch (saveError) {
+                console.error("❌ Failed to save file after history error:", saveError);
+            }
+            return {
+                success: false,
+                newVersion: "0",
+                error: errorMessage,
+            };
+        }
+    }
+    /**
+     * Gets the previous content of a README from GCS
+     * Returns undefined if file doesn't exist (first version)
+     * @param courseSlug - The slug of the course
+     * @param exerciseSlug - The slug of the exercise
+     * @param fileName - The name of the file
+     * @returns The previous content of the file or undefined if it doesn't exist
+     */
+    async getPreviousContent(courseSlug, exerciseSlug, fileName) {
+        try {
+            const filePath = `courses/${courseSlug}/exercises/${exerciseSlug}/${fileName}`;
+            const [content] = await this.bucket.file(filePath).download();
+            return content.toString();
+        }
+        catch (error) {
+            // File doesn't exist (404) - this is normal for first save
+            if (error.code === 404) {
+                return undefined;
+            }
+            console.error(`⚠️ Error downloading previous content: ${error.message}`);
+            return undefined;
+        }
+    }
+    /**
+     * Gets the current version from history
+     * @param courseSlug - The slug of the course
+     * @param exerciseSlug - The slug of the exercise
+     * @param lang - The language of the file
+     * @returns The current version of the file
+     */
+    async getCurrentVersion(courseSlug, exerciseSlug, lang) {
+        if (!this.historyManager) {
+            return "0";
+        }
+        try {
+            const status = await this.historyManager.getHistoryStatus(courseSlug, exerciseSlug, lang);
+            return status.version;
+        }
+        catch (error) {
+            console.error("⚠️ Error getting current version, defaulting to '0':", error);
+            return "0";
+        }
+    }
+    /**
+     * Saves content to Google Cloud Storage
+     * @param courseSlug - The slug of the course
+     * @param exerciseSlug - The slug of the exercise
+     * @param fileName - The name of the file
+     * @param content - The content to save
+     * @returns void
+     */
+    async saveToGCS(courseSlug, exerciseSlug, fileName, content) {
+        const filePath = `courses/${courseSlug}/exercises/${exerciseSlug}/${fileName}`;
+        const file = this.bucket.file(filePath);
+        await file.save(content, {
+            resumable: false,
+        });
+    }
+    /**
+     * Helper to get README extension from language code
+     * @param lang - The language of the file
+     * @returns The name of the README file
+     */
+    static getReadmeFileName(lang) {
+        if (lang === "en") {
+            return "README.md";
+        }
+        // es -> README.es.md, fr -> README.fr.md
+        return `README.${lang}.md`;
+    }
+}
+exports.ReadmeHistoryService = ReadmeHistoryService;

package/lib/utils/api.d.ts

@@ -15,6 +15,7 @@ type TAssetMissing = {
     slug: string;
     title: string;
     lang: string;
+    graded: boolean;
     url: string;
     description: string;
     learnpack_deploy_url: string;

package/lib/utils/api.js

@@ -341,7 +341,7 @@ const createAsset = async (token, asset) => {
         readme_url: null,
         difficulty: null,
         duration: null,
-        graded: true,
+        graded: asset.graded,
         gitpod: true,
         category: asset.category,
         owner: asset.owner,

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.328",
+  "version": "5.0.331",
   "author": "Alejandro Sanchez @alesanchezr",
   "contributors": [
     {
@@ -62,6 +62,7 @@
     "node-persist": "^3.1.0",
     "ora": "^8.2.0",
     "prompts": "^2.3.2",
+    "redis": "^5.10.0",
     "rimraf": "^6.0.1",
     "shelljs": "^0.8.4",
     "socket.io": "^4.4.1",

package/src/commands/publish.ts

@@ -47,6 +47,7 @@ export const handleAssetCreation = async (
         slug: slug,
         title: learnJson.title[selectedLang],
         lang: selectedLang,
+        graded: true,
         description: learnJson.description[selectedLang],
         learnpack_deploy_url: learnpackDeployUrl,
         technologies: learnJson.technologies.map((tech: string) =>
@@ -78,6 +79,7 @@ export const handleAssetCreation = async (
 
     Console.info("Asset exists, updating it")
     const asset = await api.updateAsset(sessionPayload.token, slug, {
+      graded: true,
       learnpack_deploy_url: learnpackDeployUrl,
       title: learnJson.title[selectedLang],
       category: category,