@learnpack/learnpack 5.0.329 → 5.0.331

package/lib/commands/serve.d.ts

@@ -17,9 +17,11 @@ export declare const createLearnJson: (courseInfo: FormState) => {
     preview: string;
 };
 export declare const processImage: (url: string, description: string, rigoToken: string, courseSlug: string) => Promise<boolean>;
-export default class ServeCommand extends SessionCommand {
+declare class ServeCommand extends SessionCommand {
     static description: string;
+    private redis;
     static flags: any;
     init(): Promise<void>;
     run(): Promise<void>;
 }
+export default ServeCommand;

package/lib/commands/serve.js

@@ -34,6 +34,9 @@ const publish_1 = require("./publish");
 const export_1 = require("../utils/export");
 const errorHandler_1 = require("../utils/errorHandler");
 const jsdom_1 = require("jsdom");
+const redis_1 = require("redis");
+const historyManager_1 = require("../managers/historyManager");
+const readmeHistoryService_1 = require("../managers/readmeHistoryService");
 const frontMatter = require("front-matter");
 if (process.env.NEW_RELIC_ENABLED === "true") {
     require("newrelic");
@@ -466,7 +469,7 @@ const getTitleFromHTML = (html) => {
     const titleMatch = html.match(titleRegex);
     return titleMatch ? titleMatch[1] : null;
 };
-async function processSyncTranslationsSequentially(courseSlug, exerciseSlug, notificationId, sourceReadmeContent, targetLanguages, rigoToken, bucket) {
+async function processSyncTranslationsSequentially(courseSlug, exerciseSlug, notificationId, sourceReadmeContent, targetLanguages, rigoToken, bucket, historyManager) {
     var _a, _b, _c, _d, _e, _f;
     try {
         // Process translations sequentially (no race conditions)
@@ -492,12 +495,25 @@ async function processSyncTranslationsSequentially(courseSlug, exerciseSlug, not
                 if (!((_a = translationResult.parsed) === null || _a === void 0 ? void 0 : _a.translation)) {
                     throw new Error("Translation result is empty");
                 }
-                // Save translated README
-                const readmePath = `courses/${courseSlug}/exercises/${exerciseSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(targetLang)}`;
+                // Save translated README with history tracking
+                const fileName = readmeHistoryService_1.ReadmeHistoryService.getReadmeFileName(targetLang);
+                const readmeHistoryService = new readmeHistoryService_1.ReadmeHistoryService(historyManager, bucket);
                 // eslint-disable-next-line no-await-in-loop
-                await bucket
-                    .file(readmePath)
-                    .save(translationResult.parsed.translation);
+                const historyResult = await readmeHistoryService.saveReadmeWithHistory({
+                    courseSlug,
+                    exerciseSlug,
+                    lang: targetLang,
+                    fileName,
+                    newContent: translationResult.parsed.translation,
+                    // Don't pass previousContent or currentVersion - let service fetch them
+                    throwOnConflict: false, // Don't fail sync on version conflicts
+                });
+                if (historyResult.success) {
+                    console.log(`🔄 SYNC: Saved ${targetLang} translation with history (version ${historyResult.newVersion})`);
+                }
+                else {
+                    console.warn(`🔄 SYNC: Translation saved but history failed for ${targetLang}: ${historyResult.error}`);
+                }
                 // Update progress in syllabus
                 // eslint-disable-next-line no-await-in-loop
                 const syllabus = await getSyllabus(courseSlug, bucket);
@@ -586,6 +602,10 @@ async function processSyncTranslationsSequentially(courseSlug, exerciseSlug, not
     }
 }
 class ServeCommand extends SessionCommand_1.default {
+    constructor() {
+        super(...arguments);
+        this.redis = null;
+    }
     async init() {
         const { flags } = this.parse(ServeCommand);
     }
@@ -608,6 +628,55 @@ class ServeCommand extends SessionCommand_1.default {
         else {
             console.log("INFO: HOST is set to", host);
         }
+        // Initialize Redis (official client)
+        const redisUrl = process.env.REDIS_URL || "redis://localhost:6379";
+        if (process.env.NODE_ENV === "production" &&
+            redisUrl === "redis://localhost:6379") {
+            console.error("❌ REDIS_URL not configured for production environment!");
+            console.warn("⚠️  History features will be unavailable");
+            this.redis = null;
+        }
+        else {
+            try {
+                const useTLS = redisUrl.startsWith("rediss://");
+                this.redis = (0, redis_1.createClient)({
+                    url: redisUrl,
+                    socket: {
+                        tls: useTLS,
+                        rejectUnauthorized: useTLS,
+                        reconnectStrategy: (retries) => {
+                            if (retries > 10) {
+                                console.error("❌ Too many Redis reconnection attempts");
+                                return new Error("Too many retries");
+                            }
+                            // Exponential backoff: 50ms, 100ms, 200ms, ...
+                            const delay = Math.min(retries * 50, 2000);
+                            return delay;
+                        },
+                    },
+                });
+                this.redis.on("error", (err) => {
+                    console.error("❌ Redis error:", err);
+                });
+                this.redis.on("connect", () => {
+                    console.log("🔄 Connecting to Redis...");
+                });
+                this.redis.on("ready", () => {
+                    console.log("✅ Connected to Redis");
+                });
+                // Connect the client
+                await this.redis.connect();
+            }
+            catch (redisError) {
+                console.error("❌ Failed to connect to Redis:", redisError);
+                console.warn("⚠️  History features (undo/redo) will be unavailable");
+                this.redis = null;
+            }
+        }
+        // Create HistoryManager instance if Redis is available
+        const historyManager = this.redis ?
+            new historyManager_1.HistoryManager(this.redis) :
+            null;
         // async function listFilesWithPrefix(prefix: string) {
         //   const [files] = await bucket.getFiles({ prefix })
         //   return files
@@ -1783,11 +1852,14 @@ class ServeCommand extends SessionCommand_1.default {
             res.set("Content-Disposition", contentDisposition);
             fileStream.pipe(res);
         });
-        app.put("/exercise/:slug/file/:fileName", express.text(), (0, errorHandler_1.asyncHandler)(async (req, res) => {
+        app.put("/exercise/:slug/file/:fileName", express.json(), (0, errorHandler_1.asyncHandler)(async (req, res) => {
             var _a, _b;
             const { slug, fileName } = req.params;
             const query = req.query;
             const courseSlug = query.slug;
+            const lang = query.lang || "en";
+            // Headers for history management
+            const versionId = req.headers["x-history-version"] || "0";
             console.log(`PUT /exercise/${slug}/file/${fileName}`);
             // Validate required parameters
             if (!courseSlug) {
@@ -1796,16 +1868,53 @@ class ServeCommand extends SessionCommand_1.default {
             if (!fileName || !slug) {
                 throw new errorHandler_1.ValidationError("File name and exercise slug are required");
             }
+            // Extract content from body (can be text or JSON)
+            let fileContent;
+            let contentToSaveInHistory;
+            if (typeof req.body === "string") {
+                // Old format: plain text
+                fileContent = req.body;
+            }
+            else if (req.body && typeof req.body === "object") {
+                // New format: JSON with content and historyContent
+                fileContent = req.body.content;
+                contentToSaveInHistory = req.body.historyContent;
+            }
+            else {
+                throw new errorHandler_1.ValidationError("Invalid request body format");
+            }
             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({
+                let newVersion = versionId;
+                let created = false;
+                // Use ReadmeHistoryService for README files with history support
+                if (fileName.startsWith("README")) {
+                    const readmeHistoryService = new readmeHistoryService_1.ReadmeHistoryService(historyManager, bucket);
+                    const historyResult = await readmeHistoryService.saveReadmeWithHistory({
+                        courseSlug,
+                        exerciseSlug: slug,
+                        lang,
+                        fileName,
+                        newContent: fileContent,
+                        previousContent: contentToSaveInHistory,
+                        currentVersion: versionId,
+                        throwOnConflict: true, // Throw error on version conflicts for manual edits
+                    });
+                    newVersion = historyResult.newVersion;
+                    created = true; // File was saved by the service
+                }
+                else {
+                    // For non-README files, save directly without history
+                    const file = bucket.file(`courses/${courseSlug}/exercises/${slug}/${fileName}`);
+                    await file.save(fileContent, {
+                        resumable: false,
+                    });
+                    const [exists] = await file.exists();
+                    created = exists;
+                }
+                res.json({
                     message: "File updated",
                     created,
+                    version: newVersion,
                 });
             }
             catch (error) {
@@ -1826,6 +1935,188 @@ class ServeCommand extends SessionCommand_1.default {
                 throw error;
             }
         }));
+        // Remove code_challenge_proposals from all README files of an exercise
+        app.post("/exercise/:slug/remove-code-proposals", (0, errorHandler_1.asyncHandler)(async (req, res) => {
+            var _a, _b;
+            const { slug } = req.params;
+            const { courseSlug } = req.body;
+            // Validate required parameters
+            if (!courseSlug) {
+                throw new errorHandler_1.ValidationError("courseSlug is required in request body");
+            }
+            console.log(`🧹 Cleaning code_challenge_proposals from exercise: ${slug} in course: ${courseSlug}`);
+            try {
+                const exerciseDir = `courses/${courseSlug}/exercises/${slug}`;
+                // Get all README files (all languages)
+                const [readmeFiles] = await bucket.getFiles({
+                    prefix: `${exerciseDir}/README`,
+                });
+                if (readmeFiles.length === 0) {
+                    return res.status(404).json({
+                        success: false,
+                        error: "No README files found for this exercise",
+                    });
+                }
+                let cleanedCount = 0;
+                const processedFiles = [];
+                // Process each README file
+                for (const readmeFile of readmeFiles) {
+                    try {
+                        // eslint-disable-next-line no-await-in-loop
+                        const [readmeContent] = await readmeFile.download();
+                        const readmeText = readmeContent.toString();
+                        // Remove code_challenge_proposal blocks, EXCEPT those in GENERATING state
+                        // The GENERATING state is identified by "GENERATING(" marker
+                        // Pattern: ```code_challenge_proposal ... ``` (but not if contains GENERATING)
+                        const codeProposalRegex = /(\r?\n)?```code_challenge_proposal(?![\S\s]*?GENERATING\()[\S\s]*?```(\r?\n)?/g;
+                        const updatedReadme = readmeText.replace(codeProposalRegex, "");
+                        // Only update if there were actual changes
+                        if (updatedReadme.trim() !== readmeText.trim()) {
+                            // eslint-disable-next-line no-await-in-loop
+                            await readmeFile.save(updatedReadme.trim(), {
+                                resumable: false,
+                            });
+                            cleanedCount++;
+                            processedFiles.push(readmeFile.name);
+                            console.log(`✅ Cleaned proposals from: ${readmeFile.name}`);
+                        }
+                    }
+                    catch (readmeError) {
+                        console.error(`❌ Error cleaning README ${readmeFile.name}:`, readmeError);
+                        // Continue processing other files even if one fails
+                    }
+                }
+                const message = cleanedCount > 0 ?
+                    `Successfully cleaned ${cleanedCount} README file(s)` :
+                    "No code challenge proposals found to clean";
+                console.log(`✅ ${message}`);
+                res.json({
+                    success: true,
+                    message,
+                    cleanedCount,
+                    processedFiles,
+                });
+            }
+            catch (error) {
+                console.error("❌ Error during code challenge proposal cleanup:", error);
+                // Handle rate limit errors
+                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,
+                    });
+                }
+                throw error;
+            }
+        }));
+        // GET /exercise/:slug/history/status
+        // Get history status (can undo/redo, current version)
+        app.get("/exercise/:slug/history/status", (0, errorHandler_1.asyncHandler)(async (req, res) => {
+            const { slug } = req.params;
+            const courseSlug = req.query.slug;
+            const lang = req.query.lang || "en";
+            if (!courseSlug) {
+                throw new errorHandler_1.ValidationError("Course slug is required");
+            }
+            if (!historyManager) {
+                return res.json({
+                    canUndo: false,
+                    canRedo: false,
+                    version: "0",
+                    available: false,
+                });
+            }
+            const status = await historyManager.getHistoryStatus(courseSlug, slug, lang);
+            res.json(Object.assign(Object.assign({}, status), { available: true }));
+        }));
+        // POST /exercise/:slug/history/undo
+        // Undo the last change
+        app.post("/exercise/:slug/history/undo", express.json(), (0, errorHandler_1.asyncHandler)(async (req, res) => {
+            const { slug } = req.params;
+            const { courseSlug, currentContent, versionId, lang } = req.body;
+            if (!courseSlug || !currentContent || !versionId) {
+                throw new errorHandler_1.ValidationError("Missing required fields: courseSlug, currentContent, versionId");
+            }
+            const language = lang || "en";
+            if (!historyManager) {
+                console.error("⏮️  HISTORY: History manager not available");
+                throw new errorHandler_1.InternalServerError("History service not available");
+            }
+            const result = await historyManager.undo(courseSlug, slug, language, currentContent, versionId);
+            if (!result.success) {
+                if (result.error === "VERSION_CONFLICT") {
+                    throw new errorHandler_1.ConflictError("Version conflict. Please refresh and try again.");
+                }
+                if (result.error === "NO_UNDO_AVAILABLE") {
+                    throw new errorHandler_1.ValidationError("No more changes to undo");
+                }
+                throw new errorHandler_1.InternalServerError(`Undo operation failed: ${result.error}`);
+            }
+            if (!result.content) {
+                throw new errorHandler_1.InternalServerError("No content returned from undo operation");
+            }
+            // Save the restored content to GCS
+            const fileName = `README${(0, creatorUtilities_1.getReadmeExtension)(language)}`;
+            const file = bucket.file(`courses/${courseSlug}/exercises/${slug}/${fileName}`);
+            try {
+                await file.save(result.content, {
+                    resumable: false,
+                });
+            }
+            catch (gcsError) {
+                console.error("⏮️  HISTORY: Failed to save restored content to GCS:", gcsError);
+                throw new errorHandler_1.InternalServerError("Failed to save restored content");
+            }
+            res.json({
+                content: result.content,
+                version: result.newVersion,
+            });
+        }));
+        // POST /exercise/:slug/history/redo
+        // Redo the last undone change
+        app.post("/exercise/:slug/history/redo", express.json(), (0, errorHandler_1.asyncHandler)(async (req, res) => {
+            const { slug } = req.params;
+            const { courseSlug, currentContent, versionId, lang } = req.body;
+            if (!courseSlug || !currentContent || !versionId) {
+                throw new errorHandler_1.ValidationError("Missing required fields: courseSlug, currentContent, versionId");
+            }
+            const language = lang || "en";
+            if (!historyManager) {
+                console.error("⏮️  HISTORY: History manager not available");
+                throw new errorHandler_1.InternalServerError("History service not available");
+            }
+            const result = await historyManager.redo(courseSlug, slug, language, currentContent, versionId);
+            if (!result.success) {
+                if (result.error === "VERSION_CONFLICT") {
+                    throw new errorHandler_1.ConflictError("Version conflict. Please refresh and try again.");
+                }
+                if (result.error === "NO_REDO_AVAILABLE") {
+                    throw new errorHandler_1.ValidationError("No more changes to redo");
+                }
+                throw new errorHandler_1.InternalServerError(`Redo operation failed: ${result.error}`);
+            }
+            if (!result.content) {
+                throw new errorHandler_1.InternalServerError("No content returned from redo operation");
+            }
+            // Save the restored content to GCS
+            const fileName = `README${(0, creatorUtilities_1.getReadmeExtension)(language)}`;
+            const file = bucket.file(`courses/${courseSlug}/exercises/${slug}/${fileName}`);
+            try {
+                await file.save(result.content, {
+                    resumable: false,
+                });
+            }
+            catch (gcsError) {
+                console.error("⏮️  HISTORY: Failed to save restored content to GCS:", gcsError);
+                throw new errorHandler_1.InternalServerError("Failed to save restored content");
+            }
+            res.json({
+                content: result.content,
+                version: result.newVersion,
+            });
+        }));
         // Create a new step for a course
         app.post("/course/:slug/create-step", async (req, res) => {
             console.log("POST /course/:slug/create-step");
@@ -2372,7 +2663,7 @@ class ServeCommand extends SessionCommand_1.default {
                     targetLanguages: targetLanguages.length,
                 });
                 // Process translations sequentially (no race conditions)
-                processSyncTranslationsSequentially(courseSlug, exerciseSlug, notificationId, sourceReadmeContent, targetLanguages, rigoToken, bucket).catch(error => {
+                processSyncTranslationsSequentially(courseSlug, exerciseSlug, notificationId, sourceReadmeContent, targetLanguages, rigoToken, bucket, historyManager).catch(error => {
                     console.error("Error in sync translation processing:", error);
                     // Update notification with critical error
                     getSyllabus(courseSlug, bucket).then(syl => {

package/lib/managers/historyManager.d.ts

@@ -0,0 +1,67 @@
+import type { RedisClientType } from "redis";
+export interface HistoryResult {
+    success: boolean;
+    newVersion?: string;
+    content?: string;
+    error?: string;
+}
+export interface HistoryStatus {
+    canUndo: boolean;
+    canRedo: boolean;
+    version: string;
+}
+export declare class HistoryManager {
+    private redis;
+    private saveStateLua;
+    private undoLua;
+    private redoLua;
+    private readonly TTL;
+    private readonly LIMIT;
+    constructor(redisClient: RedisClientType);
+    /**
+     * 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
+     */
+    private getKeys;
+    /**
+     * 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
+     */
+    saveState(courseSlug: string, exerciseSlug: string, lang: string, content: string, versionId: string): Promise<HistoryResult>;
+    /**
+     * 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
+     */
+    undo(courseSlug: string, exerciseSlug: string, lang: string, currentContent: string, versionId: string): Promise<HistoryResult>;
+    /**
+     * 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
+     */
+    redo(courseSlug: string, exerciseSlug: string, lang: string, currentContent: string, versionId: string): Promise<HistoryResult>;
+    /**
+     * 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
+     */
+    getHistoryStatus(courseSlug: string, exerciseSlug: string, lang: string): Promise<HistoryStatus>;
+}

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;