@fullstackcraftllc/codevideo-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,1372 @@
+import dotenv from 'dotenv';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { AllActionStrings, isRepeatableAction, isValidAction } from '@fullstackcraftllc/codevideo-types';
+import { VirtualIDE } from '@fullstackcraftllc/codevideo-virtual-ide';
+import Database from 'better-sqlite3';
+import path, { join } from 'path';
+import os, { platform, arch } from 'os';
+import fs, { existsSync } from 'fs';
+import { buildFileStructureFromRootFolder } from '@fullstackcraftllc/codevideo-adapters';
+import { GoogleGenAI } from '@google/genai';
+import { generateMarkdownStringFromActions, generateHtmlStringFromActions } from '@fullstackcraftllc/codevideo-exporters';
+import { spawn } from 'child_process';
+
+var version = "1.0.0";
+
+// this prompt describes how to create a course lesson using the CodeVideo framework
+const instructionsToCreateACourse = (additionalContext) => {
+    return `You are an expert senior software engineer and educator, and skilled in describing software concepts in a way that is easy for students to understand. You are going to create a course using the CodeVideo framework, a framework that uses simple JSON to generate software courses and lessons in a variety of formats (video, markdown, pdf, and more).
+
+    There are a few rules to uphold when making a CodeVideo course:
+
+    1. The final course snapshot of the previous lesson must be equivalent to the initial course snapshot of the next lesson.
+    2. Beyond the first lesson, each lesson must start with an \`author-speak-before\` action that summarizes the previous lesson with a maximum of 3 sentences.
+    3. Beyond the first lesson, each lesson must have their second action be an \`author-speak-during\` action that summarizes the current lesson with a maximum of 3 sentences.
+    4. Beyond the first lesson, each lesson must end with an \`author-speak-after\` action that summarizes the current lesson with a maximum of 3 sentences.
+
+    With these rules in mind, please create a course with the following lessons:
+    
+    ${additionalContext}
+
+    Now, you should first think of a name and description for this course, they should be SEO friendly title and meta description respectively. 
+    
+    To create the initial course object, you can call the MCP tool \`codevideo_create_course_with_initial_metadata\` with the following parameters:
+    - id: a unique identifier for the course
+    - name: the name of the course
+    - description: the description of the course
+    - primaryLanguage: the primary language of the course
+    
+    You should then plan out the number of lessons and what they will be about. To add a lesson to the course, you can call the MCP tool \`codevideo_add_lesson_to_course\` with the following parameters:
+    - id: a unique identifier for the lesson. it should relate to the course id, for example if the course id is \`generics-in-typescript\`, the lesson id should be something like \`generics-in-typescript-lesson-1-introduction\`
+    - name: the name of the lesson
+    - description: the description of the lesson
+
+    You then need to create the initial lesson snapshot. For the very first lesson, you can call the tool \`codevideo_get_empty_lesson_snapshot\` without any parameters to get an empty lesson snapshot object. For the rest of the lessons, you can copy the final lesson snapshot of the previous lesson and use that as the initial lesson snapshot.
+
+    You then need to add actions to the lesson. First read the prompt in \`codevideo_instructions_to_create_lesson_actions\` to get the instructions on how to create lesson actions. 
+    
+    When done creating actions, you can add actions to the lesson by calling the MCP tool \`codevideo_add_actions_to_lesson\` with the following parameters:
+    - lesson: the ILesson object that you created earlier
+    - actions: the array of IAction objects that you created earlier
+
+    WORKFLOW TIP: For efficiency, after creating actions for each lesson, you can call \`codevideo_set_current_actions\` to store them, then use \`codevideo_get_final_lesson_snapshot\` without the actions parameter (it will use the stored actions automatically).
+
+    For each lesson, you also need to create the final lesson snapshot. You can get the final snapshot the lesson by calling the MCP tool \`codevideo_get_final_lesson_snapshot\` with the following parameters:
+    - actions: the array of IAction objects that you created earlier for the lesson (OR omit this parameter if you've called \`codevideo_set_current_actions\` first)
+
+    In summary, the steps to create a course are:
+
+    1. Create the initial course object using the MCP tool \`codevideo_create_course_with_initial_metadata\`
+    2. Plan out the number of lessons needed and what they will be about
+    3. For each lesson, create a unique identifier, name, and description
+    4. Create the initial empty lesson snapshot for the first lesson using the MCP tool \`codevideo_get_empty_lesson_snapshot\`. In the case of lessons beyond the first, copy the final lesson snapshot of the previous lesson and use that as the initial lesson snapshot.
+    5. Create actions for the lesson using the MCP tool \`codevideo_instructions_to_create_lesson_actions\`
+    6. Add actions to the lesson using the MCP tool \`codevideo_add_actions_to_lesson\`
+    7. Create the final lesson snapshot using the MCP tool \`codevideo_get_final_lesson_snapshot\`
+    8. Add the lesson to the course using the MCP tool \`codevideo_add_lesson_to_course\`
+    9. Repeat steps 4-8 for each lesson
+
+    When done, return the completed course object as a JSON string.
+    
+    Good luck, and enjoy creating your course!`;
+};
+
+// this prompt describes how to make lesson actions in the CodeVideo framework
+const instructionsToCreateLessonActions = (additionalContext) => {
+    return `You are an expert senior software engineer and educator, and skilled in describing software concepts in a way that is easy for students to understand. You are going to create lesson actions using the CodeVideo framework, a framework that uses simple JSON to generate tutorials in a variety of formats (video, markdown, pdf, and more). This JSON array is always an array of simple \`IAction\`:
+
+    \`\`\`typescript
+    export interface IAction {
+        name: AllActions;
+        value: string;
+    }
+    \`\`\`
+
+
+    Where \`AllActions\` is:
+
+    \`\`\`typescript
+    import { AuthorActions } from "./AuthorActions";
+    import { MouseActions } from "./MouseActions";
+    import { FileExplorerActions } from "./FileExplorerActions";
+    import { TerminalActions } from "./TerminalActions";
+    import { EditorActions } from "./EditorActions";
+    import { ExternalActions } from "./ExternalActions";
+
+    // all actions combines the 5 domains of the CodeVideo world
+    export type AllActions =
+    | AuthorActions
+    | FileExplorerActions
+    | EditorActions
+    | MouseActions
+    | TerminalActions
+    | AuthorActions
+    | ExternalActions;
+    \`\`\`
+
+    Here are all the action types you have to choose from:
+
+    \`\`\`typescript
+    export const AllActionStrings = [
+        ${AllActionStrings.map((action) => `"${action}"`).join(",\n        ")}
+    ];
+    \`\`\`
+
+    When in doubt with these names, feel free to use the MCP tool \`codevideo_get_action_names\` to get the most updated list of all the actions available. You can also use the MCP tool \`codevideo_get_example_lesson\` to get verified, accurate, and correct lessons created by humans.
+    
+    Also VERY IMPORTANT to note, while most 'value' properties are corresponding strings, things like \`editor-enter\` are considered "Repeatable" properties, which MUST have a string number as the 'value' property, which is 99% of the time the string "1", but can be any positive integer, representing the number of times to repeat. An action can be checked for repeatability with the MCP tool \`codevideo_is_repeatable_action\`. To be stressed again: the "value" property of any codevideo action CANNOT be left empty!
+
+    WORKFLOW TIP: After creating actions, you can store them using \`codevideo_set_current_actions\` and then use other tools like \`codevideo_validate_actions\`, \`codevideo_make_video\`, \`codevideo_make_blog_post\`, etc. without needing to re-specify the actions each time. These tools will automatically retrieve the stored actions if no actions parameter is provided.
+
+    RECOMMENDED WORKFLOW:
+    1. Create your actions array
+    2. Call \`codevideo_set_current_actions\` once with the actions
+    3. Call \`codevideo_validate_actions\` WITHOUT the actions parameter - it will use the stored actions automatically - if issues are found, fix them in the actions array and call \`codevideo_set_current_actions\` again
+    4. Call any other tools (make_video, make_blog_post, etc.) WITHOUT the actions parameter - they will use the stored actions automatically
+    5. Use \`codevideo_get_current_actions\` at any later time to inspect what's currently stored if needed
+
+    With all this in mind, you are to create a lesson about the following:
+
+    ${additionalContext}
+
+    Be sure to include a corresponding initial \`author-speak-before\` action and a final summary \`author-speak-before\` action.
+    `;
+};
+
+// this prompt describes how to make lesson actions in the CodeVideo framework
+const instructionsToCreateLessonVideo = (additionalContext) => {
+    return `You are an expert senior software engineer and educator, and skilled in describing software concepts in a way that is easy for students to understand. You are going to create a video lesson using the CodeVideo framework, a framework that uses simple JSON to generate tutorials in a variety of formats (video, markdown, pdf, and more). The JSON array used to create video is always an array of simple type \`IAction\`:
+
+    \`\`\`typescript
+    export interface IAction {
+        name: AllActions;
+        value: string;
+    }
+    \`\`\`
+
+
+    Where \`AllActions\` is:
+
+    \`\`\`typescript
+    import { AuthorActions } from "./AuthorActions";
+    import { MouseActions } from "./MouseActions";
+    import { FileExplorerActions } from "./FileExplorerActions";
+    import { TerminalActions } from "./TerminalActions";
+    import { EditorActions } from "./EditorActions";
+    import { ExternalActions } from "./ExternalActions";
+
+    // all actions combines the 5 domains of the CodeVideo world
+    export type AllActions =
+    | AuthorActions
+    | FileExplorerActions
+    | EditorActions
+    | MouseActions
+    | TerminalActions
+    | AuthorActions
+    | ExternalActions;
+    \`\`\`
+
+    Here are all the action types you have to choose from:
+
+    \`\`\`typescript
+    export const AllActionStrings = [
+        ${AllActionStrings.map((action) => `"${action}"`).join(",\n        ")}
+    ];
+    \`\`\`
+
+    When in doubt with these names, feel free to use the MCP tool \`codevideo_get_action_names\` to get the most updated list of all the actions available. You can also use the MCP tool \`codevideo_get_example_lesson\` to get verified, accurate, and correct lessons created by humans.
+    
+    Also VERY IMPORTANT to note, while most 'value' properties are corresponding strings, things like \`editor-enter\` are considered "Repeatable" properties, which MUST have a string number as the 'value' property, which is 99% of the time the string "1", but can be any positive integer, representing the number of times to repeat. An action can be checked for repeatability with the MCP tool \`codevideo_is_repeatable_action\`. To be stressed again: the "value" property of any codevideo action CANNOT be left empty!
+
+    RECOMMENDED WORKFLOW:
+    1. Create your actions array
+    2. Call \`codevideo_set_current_actions\` once with the actions
+    3. Call \`codevideo_validate_actions\` WITHOUT the actions parameter - it will use the stored actions automatically - if issues are found, fix them in the actions array and call \`codevideo_set_current_actions\` again
+    4. Call \`codevideo_make_video\` WITHOUT the actions parameter - it will use the stored actions automatically
+
+    With all this in mind, you are to create a lesson about the following:
+
+    ${additionalContext}
+
+    Be sure to include a corresponding initial \`author-speak-before\` action and a final summary \`author-speak-before\` action.
+    `;
+};
+
+// retrieves the current actions from the key value sqlite database
+const getCurrentActions = () => {
+    try {
+        const homeDir = os.homedir();
+        const dbPath = path.join(homeDir, '.codevideo', 'codevideo.db');
+        // Check if database file exists
+        if (!fs.existsSync(dbPath)) {
+            return null;
+        }
+        // Open database
+        const db = new Database(dbPath);
+        // Check if table exists
+        const tableExists = db.prepare(`
+            SELECT name FROM sqlite_master 
+            WHERE type='table' AND name='key_value_store'
+        `).get();
+        if (!tableExists) {
+            db.close();
+            return null;
+        }
+        // Retrieve current_actions
+        const stmt = db.prepare(`
+            SELECT value FROM key_value_store 
+            WHERE key = ?
+        `);
+        const result = stmt.get('current_actions');
+        db.close();
+        if (!result) {
+            return null;
+        }
+        // Parse JSON back to actions array
+        const actions = JSON.parse(result.value);
+        return actions;
+    }
+    catch (error) {
+        console.error('Error retrieving actions:', error);
+        return null;
+    }
+};
+// Helper function that returns actions or throws descriptive error
+const getCurrentActionsOrThrow = () => {
+    const actions = getCurrentActions();
+    if (!actions) {
+        throw new Error('No actions found in storage. Please use codevideo_set_current_actions first to store actions, then try again.');
+    }
+    return actions;
+};
+
+const getFinalLessonSnapshot = (actions) => {
+    // Use provided actions or retrieve from storage
+    const actionsToUse = actions || getCurrentActionsOrThrow();
+    // create a new instance of codevideo virtual ide
+    const virtualIDE = new VirtualIDE();
+    // apply all actions to the virtual IDE
+    virtualIDE.applyActions(actionsToUse);
+    // get the final snapshot of the virtual IDE
+    const finalSnapshot = virtualIDE.getCourseSnapshot();
+    // return the final snapshot as a string
+    return JSON.stringify(finalSnapshot, null, 2);
+};
+
+const getInitialLessonStateFromLocalCodebase = async (repoLocation) => {
+    // build file structure from files and content from the file system adapter
+    const fileStructure = await buildFileStructureFromRootFolder(repoLocation);
+    // build the project using the file structure
+    const project = {
+        id: "",
+        name: "",
+        description: "",
+        actions: [],
+        initialSnapshot: {
+            isUnsavedChangesDialogOpen: false,
+            unsavedFileName: '',
+            fileExplorerSnapshot: {
+                isFileExplorerContextMenuOpen: false,
+                isFileContextMenuOpen: false,
+                isFolderContextMenuOpen: false,
+                isNewFileInputVisible: false,
+                isNewFolderInputVisible: false,
+                isRenameFileInputVisible: false,
+                isRenameFolderInputVisible: false,
+                newFileInputValue: '',
+                newFolderInputValue: '',
+                renameFileInputValue: '',
+                renameFolderInputValue: '',
+                originalFileBeingRenamed: '',
+                originalFolderBeingRenamed: '',
+                newFileParentPath: '',
+                newFolderParentPath: '',
+                fileStructure,
+            },
+            editorSnapshot: {
+                isEditorContextMenuOpen: false,
+                editors: []
+            },
+            terminalSnapshot: {
+                terminals: []
+            },
+            mouseSnapshot: {
+                location: 'editor',
+                currentHoveredFileName: '',
+                currentHoveredFolderName: '',
+                currentHoveredEditorTabFileName: '',
+                x: 0,
+                y: 0,
+                timestamp: 0,
+                type: 'move',
+                buttonStates: {
+                    left: false,
+                    right: false,
+                    middle: false,
+                },
+                scrollPosition: {
+                    x: 0,
+                    y: 0
+                },
+            },
+            authorSnapshot: {
+                authors: [
+                    { currentSpeechCaption: '' }
+                ]
+            }
+        }
+    };
+    // return the project as a string
+    return JSON.stringify(project);
+};
+
+const isRepeatable = (action) => {
+    return isRepeatableAction(action) ? "true" : "false";
+};
+
+const createCourseWithInitialMetadata = (id, name, description, primaryLanguage) => {
+    const course = {
+        id,
+        name,
+        description,
+        primaryLanguage,
+        lessons: []
+    };
+    return JSON.stringify(course, null, 2);
+};
+
+const addLessonToCourse = (course, id, name, description) => {
+    const lesson = {
+        id,
+        name,
+        description,
+        actions: [],
+        initialSnapshot: {
+            isUnsavedChangesDialogOpen: false,
+            unsavedFileName: '',
+            fileExplorerSnapshot: {
+                isFileExplorerContextMenuOpen: false,
+                isFileContextMenuOpen: false,
+                isFolderContextMenuOpen: false,
+                isNewFileInputVisible: false,
+                isNewFolderInputVisible: false,
+                isRenameFileInputVisible: false,
+                isRenameFolderInputVisible: false,
+                newFileInputValue: '',
+                newFolderInputValue: '',
+                renameFileInputValue: '',
+                renameFolderInputValue: '',
+                originalFileBeingRenamed: '',
+                originalFolderBeingRenamed: '',
+                newFileParentPath: '',
+                newFolderParentPath: '',
+                fileStructure: {},
+            },
+            editorSnapshot: {
+                isEditorContextMenuOpen: false,
+                editors: []
+            },
+            terminalSnapshot: {
+                terminals: []
+            },
+            mouseSnapshot: {
+                location: 'editor',
+                currentHoveredFileName: '',
+                currentHoveredFolderName: '',
+                currentHoveredEditorTabFileName: '',
+                x: 0,
+                y: 0,
+                timestamp: 0,
+                type: 'move',
+                buttonStates: {
+                    left: false,
+                    right: false,
+                    middle: false,
+                },
+                scrollPosition: {
+                    x: 0,
+                    y: 0
+                },
+            },
+            authorSnapshot: {
+                authors: [
+                    { currentSpeechCaption: '' }
+                ]
+            }
+        }
+    };
+    // Add the lesson to the course
+    course.lessons.push(lesson);
+    // Return the updated course object
+    return JSON.stringify(course, null, 2);
+};
+
+const addActionsToLesson = (lesson, actions) => {
+    lesson.actions = actions;
+    return JSON.stringify(lesson, null, 2);
+};
+
+const getEmptyLessonSnapshot = () => {
+    const snapshot = {
+        isUnsavedChangesDialogOpen: false,
+        unsavedFileName: '',
+        fileExplorerSnapshot: {
+            isFileExplorerContextMenuOpen: false,
+            isFileContextMenuOpen: false,
+            isFolderContextMenuOpen: false,
+            isNewFileInputVisible: false,
+            isNewFolderInputVisible: false,
+            isRenameFileInputVisible: false,
+            isRenameFolderInputVisible: false,
+            newFileInputValue: '',
+            newFolderInputValue: '',
+            renameFileInputValue: '',
+            renameFolderInputValue: '',
+            originalFileBeingRenamed: '',
+            originalFolderBeingRenamed: '',
+            newFileParentPath: '',
+            newFolderParentPath: '',
+            fileStructure: {},
+        },
+        editorSnapshot: {
+            isEditorContextMenuOpen: false,
+            editors: []
+        },
+        terminalSnapshot: {
+            terminals: []
+        },
+        mouseSnapshot: {
+            location: 'editor',
+            currentHoveredFileName: '',
+            currentHoveredFolderName: '',
+            currentHoveredEditorTabFileName: '',
+            x: 0,
+            y: 0,
+            timestamp: 0,
+            type: 'move',
+            buttonStates: {
+                left: false,
+                right: false,
+                middle: false,
+            },
+            scrollPosition: {
+                x: 0,
+                y: 0
+            },
+        },
+        authorSnapshot: {
+            authors: [
+                { currentSpeechCaption: '' }
+            ]
+        }
+    };
+    // return the snapshot as a string
+    return JSON.stringify(snapshot, null, 2);
+};
+
+const critiqueVideoUsingGemini = async (videoPath, actions) => {
+    // Use provided actions or retrieve from storage
+    const actionsToUse = actions || getCurrentActionsOrThrow();
+    // Check if GEMINI_API_KEY is set in the environment
+    const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
+    if (!GEMINI_API_KEY) {
+        throw new Error('GEMINI_API_KEY environment variable is not set');
+    }
+    // Initialize the Gemini API client
+    const ai = new GoogleGenAI({ apiKey: GEMINI_API_KEY });
+    const prompt = `You are an expert senior software engineer and educator, and skilled in describing software concepts in a way that is easy for students to understand. You are going to critique a procedurally generated software video lesson for clarity, accuracy, and correctness. The video and the lesson actions are attached. Your tasks:
+    
+    1. Watch the video and read the lesson actions.
+    2. Critique the video for clarity, accuracy, and correctness. Of particular note is any audio artifacts or strange wordings. Do not suggest any new material, only critique the existing material.
+    3. Provide a summary of your critique, including any errors or inaccuracies you found, and at what action they occur at.`;
+    try {
+        // Read the video file as a binary blob for the API
+        const videoBuffer = fs.readFileSync(videoPath);
+        const videoBase64 = videoBuffer.toString('base64');
+        // Convert actions array to JSON string
+        const actionsJson = JSON.stringify(actionsToUse, null, 2);
+        // Prepare the request with content parts including text and file data
+        const response = await ai.models.generateContent({
+            model: 'gemini-2.5-pro-preview-05-06',
+            contents: [
+                {
+                    role: 'user',
+                    parts: [
+                        { text: prompt },
+                        {
+                            fileData: {
+                                mimeType: 'video/mp4',
+                                fileUri: `data:video/mp4;base64,${videoBase64}`
+                            }
+                        },
+                        {
+                            text: `Here are the lesson actions in JSON format:\n\n${actionsJson}`
+                        }
+                    ]
+                }
+            ]
+        });
+        // Get the response text
+        const result = response.text;
+        return result || "No critique was generated";
+    }
+    catch (error) {
+        console.error('Error during Gemini API call:', error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to critique video using Gemini: ${errorMessage}`);
+    }
+};
+
+// sets the current actions to the key value sqlite database
+const setCurrentActions = (actions) => {
+    try {
+        // Create database directory if it doesn't exist
+        const homeDir = os.homedir();
+        const dbDir = path.join(homeDir, '.codevideo');
+        if (!fs.existsSync(dbDir)) {
+            fs.mkdirSync(dbDir, { recursive: true });
+        }
+        const dbPath = path.join(dbDir, 'codevideo.db');
+        // Open or create database
+        const db = new Database(dbPath);
+        // Create table if it doesn't exist
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS key_value_store (
+                key TEXT PRIMARY KEY,
+                value TEXT NOT NULL,
+                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        // Prepare statement to insert or replace the current_actions
+        const stmt = db.prepare(`
+            INSERT OR REPLACE INTO key_value_store (key, value, updated_at) 
+            VALUES (?, ?, CURRENT_TIMESTAMP)
+        `);
+        // Convert actions to JSON string and store
+        const actionsJson = JSON.stringify(actions);
+        stmt.run('current_actions', actionsJson);
+        db.close();
+        return `Successfully stored ${actions.length} actions in local database at ${dbPath}`;
+    }
+    catch (error) {
+        return `Error storing actions: ${error.message}`;
+    }
+};
+
+// calls the markdown generator from the codevideo-exporters package
+const makeBlogPost = (actions) => {
+    // Use provided actions or retrieve from storage
+    const actionsToUse = actions || getCurrentActionsOrThrow();
+    return generateMarkdownStringFromActions(actionsToUse);
+};
+
+// calls the HTML generator from the codevideo-exporters package
+const makeHTMLWebPage = async (actions) => {
+    // Use provided actions or retrieve from storage
+    const actionsToUse = actions || getCurrentActionsOrThrow();
+    // Generate the HTML content
+    const htmlContent = await generateHtmlStringFromActions(actionsToUse);
+    // Create output file on desktop with timestamp
+    const homeDir = os.homedir();
+    const desktopDir = path.join(homeDir, 'Desktop');
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const outputFile = path.join(desktopDir, `codevideo-${timestamp}.html`);
+    // Write HTML to file
+    fs.writeFileSync(outputFile, htmlContent, 'utf8');
+    // Open the HTML file in the default browser
+    const openChild = spawn('open', [outputFile], {
+        detached: true,
+        stdio: 'ignore'
+    });
+    openChild.unref();
+    // Return the HTML content
+    return htmlContent;
+};
+
+function getBinaryPath() {
+    const platformMap = {
+        'darwin': 'darwin',
+        'linux': 'linux',
+        'win32': 'win32'
+    };
+    const archMap = {
+        'x64': 'x64',
+        'arm64': 'arm64'
+    };
+    const targetPlatform = platformMap[platform()];
+    const targetArch = archMap[arch()];
+    if (!targetPlatform || !targetArch) {
+        throw new Error(`Unsupported platform: ${platform()}-${arch()}`);
+    }
+    const binaryName = platform() === 'win32' ? 'codevideo-cli.exe' : 'codevideo-cli';
+    const binaryPath = join(__dirname, '..', 'bin', `${targetPlatform}-${targetArch}`, binaryName);
+    if (!existsSync(binaryPath)) {
+        throw new Error(`Binary not found for ${targetPlatform}-${targetArch} at ${binaryPath}`);
+    }
+    return binaryPath;
+}
+
+const makeVideo = async (actions) => {
+    try {
+        const binaryPath = getBinaryPath(); // Use bundled binary instead of PATH_TO_CODEVIDEO_CLI
+        // Use provided actions or retrieve from storage
+        const actionsToUse = actions || getCurrentActionsOrThrow();
+        // Create JSON string directly
+        const actionsJson = JSON.stringify(actionsToUse);
+        // Create output file on desktop with timestamp
+        const homeDir = os.homedir();
+        const desktopDir = path.join(homeDir, 'Desktop');
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const outputFile = path.join(desktopDir, `codevideo-${timestamp}.mp4`);
+        // Fire-and-forget: Start the video generation process in the background
+        const child = spawn(binaryPath, ['make-video'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            cwd: process.cwd()
+        });
+        // Unreference the child process, allowing the parent to exit independently
+        child.unref();
+        // Return immediately with status message
+        return {
+            outputPath: outputFile,
+            stdout: `Video generation job with ${actionsToUse.length} actions started in the background via the codevideo-cli command. MP4 file path: ${outputFile}. It should open automatically as soon as it is done being rendered.`,
+            stderr: ''
+        };
+    }
+    catch (error) {
+        console.error('Error starting video generation:', error);
+        return {
+            outputPath: '',
+            stdout: '',
+            stderr: `Failed to start video generation: ${error.message}`,
+            error
+        };
+    }
+};
+
+/**
+ * Validates the actions so the LLM can correct any mistakes it makes
+ *
+ */
+const validateActions = (actions) => {
+    // Use provided actions or retrieve from storage
+    const actionsToUse = actions || getCurrentActionsOrThrow();
+    // loop over all actions and call the isValidAction function from the types package
+    const errorMessages = [];
+    for (var i = 0; i < actionsToUse.length; i++) {
+        const action = actionsToUse[i];
+        // codevideo-types package should cover all action types - normal and repeatable!
+        if (!isValidAction(action)) {
+            errorMessages.push(`Invalid action at action index ${i}: ${JSON.stringify(action)}. Hint: if this action 'name' is a repeatable action, the 'value' property must be a number. To repeat once, simply use the string "1".`);
+        }
+    }
+    if (errorMessages.length > 0) {
+        return JSON.stringify({ isError: true, errorMessages });
+    }
+    return JSON.stringify({ isError: false, errorMessages: [] });
+};
+
+/**
+ * Returns all action names exported by the codevideo-types package, joined by commas.
+ */
+const getActionNames = () => {
+    return AllActionStrings.join(", ");
+};
+
+const keywordsToExampleMap = [
+    {
+        keywords: ["console log", "javascript", "js", "log"],
+        actions: [
+            {
+                name: "author-speak-before",
+                value: "Today we're going to learn about console.log in JavaScript. Console.log is a function that allows you to print messages to the console, which is useful for debugging and understanding your code better.",
+            },
+            {
+                name: "author-speak-before",
+                value: "Let's first create an index.js file where we will write our code.",
+            },
+            {
+                name: "mouse-move-file-explorer",
+                value: "1",
+            },
+            {
+                name: "mouse-right-click",
+                value: "1",
+            },
+            {
+                name: "mouse-move-file-explorer-context-menu-new-file",
+                value: "1",
+            },
+            {
+                name: "mouse-left-click",
+                value: "1",
+            }
+        ]
+    },
+    {
+        keywords: ["golang", "go", "golang console log", "golang log"],
+        actions: [
+            {
+                "name": "author-speak-before",
+                "value": "Let's learn how to use the fmt.Println function in Go!"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "Let's first make a main.go file."
+            },
+            {
+                "name": "mouse-move-file-explorer",
+                "value": "1"
+            },
+            {
+                "name": "mouse-right-click",
+                "value": "1"
+            },
+            {
+                "name": "mouse-move-file-explorer-context-menu-new-file",
+                "value": "1"
+            },
+            {
+                "name": "mouse-left-click",
+                "value": "1"
+            },
+            {
+                "name": "file-explorer-type-new-file-input",
+                "value": "main.go"
+            },
+            {
+                "name": "file-explorer-enter-new-file-input",
+                "value": "1"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "First, we'll need to declare the main package, and then the main function."
+            },
+            {
+                "name": "editor-type",
+                "value": "package main"
+            },
+            {
+                "name": "editor-enter",
+                "value": "2"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "And we'll need the fmt package to use the Println function."
+            },
+            {
+                "name": "editor-type",
+                "value": 'import "fmt"'
+            },
+            {
+                "name": "editor-enter",
+                "value": "1"
+            },
+            {
+                "name": "editor-type",
+                "value": "func main() {"
+            },
+            {
+                "name": "editor-enter",
+                "value": "1"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "and let's just print 'Hello world!' to the console."
+            },
+            {
+                "name": "editor-type",
+                "value": '    fmt.Println("Hello, world!")'
+            },
+            {
+                "name": "editor-enter",
+                "value": "1"
+            },
+            {
+                "name": "editor-type",
+                "value": "}"
+            },
+            {
+                "name": "editor-arrow-up",
+                "value": "1"
+            },
+            {
+                "name": "editor-command-right",
+                "value": "1"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "and if I wanted to write the value of some variable to the console, I could do that like so:"
+            },
+            {
+                "name": "editor-backspace",
+                "value": "32"
+            },
+            {
+                "name": "editor-type",
+                "value": "    myVariable := 5"
+            },
+            {
+                "name": "editor-enter",
+                "value": "1"
+            },
+            {
+                "name": "editor-type",
+                "value": "    fmt.Println(myVariable)"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "Now, when I run this code, I would expect the value of 'myVariable' to be printed to the console. Something like:"
+            },
+            {
+                "name": "editor-enter",
+                "value": "1"
+            },
+            {
+                "name": "editor-type",
+                "value": "    // 5"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "Console logging is simple, yet powerful and very useful!"
+            }
+        ]
+    },
+    {
+        keywords: ["python", "python console log", "python log"],
+        actions: [
+            {
+                "name": "author-speak-before",
+                "value": "Let's learn how to use the print function in Python!"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "First, let's make a main.py Python file."
+            },
+            {
+                "name": "mouse-move-file-explorer",
+                "value": "1"
+            },
+            {
+                "name": "mouse-right-click",
+                "value": "1"
+            },
+            {
+                "name": "mouse-move-file-explorer-context-menu-new-file",
+                "value": "1"
+            },
+            {
+                "name": "mouse-left-click",
+                "value": "1"
+            },
+            {
+                "name": "file-explorer-type-new-file-input",
+                "value": "main.py"
+            },
+            {
+                "name": "file-explorer-enter-new-file-input",
+                "value": "1"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "and let's print 'Hello world!' to the console."
+            },
+            {
+                "name": "editor-type",
+                "value": "print('Hello, world!')"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "and if I wanted to write the value of some variable to the console, I could do that like so:"
+            },
+            {
+                "name": "editor-backspace",
+                "value": "22"
+            },
+            {
+                "name": "editor-type",
+                "value": "my_variable = 5"
+            },
+            {
+                "name": "editor-enter",
+                "value": "1"
+            },
+            {
+                "name": "editor-type",
+                "value": "print(my_variable)"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "Now, when I run this code, I would expect the value of 'my_variable' to be printed to the console. Something like:"
+            },
+            {
+                "name": "editor-enter",
+                "value": "1"
+            },
+            {
+                "name": "editor-type",
+                "value": "# 5"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "Console logging is simple, yet powerful and very useful!"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "Well done, lets save our file."
+            },
+            {
+                "name": "editor-save",
+                "value": "main.py"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "Saved!"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "Oh... and I've just realized... this file looks a bit strange... let's add the python shebang to the top of the file."
+            },
+            {
+                "name": "editor-arrow-up",
+                "value": "4"
+            },
+            {
+                "name": "editor-command-left",
+                "value": "1"
+            },
+            {
+                "name": "editor-enter",
+                "value": "1"
+            },
+            {
+                "name": "editor-arrow-up",
+                "value": "1"
+            },
+            {
+                "name": "editor-type",
+                "value": "#!/usr/bin/env python"
+            },
+            {
+                "name": "editor-enter",
+                "value": "1"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "Ah...much better!"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "Let's save the file again."
+            },
+            {
+                "name": "editor-save",
+                "value": "main.py"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "Saved!"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "Now, let's open a terminal and run this file..."
+            },
+            {
+                "name": "terminal-open",
+                "value": "1"
+            },
+            {
+                "name": "terminal-type",
+                "value": "python main.py"
+            },
+            {
+                "name": "terminal-set-output",
+                "value": "5"
+            },
+            {
+                "name": "terminal-enter",
+                "value": "1"
+            },
+            {
+                "name": "author-speak-before",
+                "value": "Perfect, our code is working as expected! I hope you enjoyed this lesson!"
+            }
+        ]
+    },
+];
+// returns a JSON representation of an example lesson based on keywords
+// the LLM can use this to learn real example lessons created by humans
+const getExampleLesson = (keyword) => {
+    const exampleJSONs = [];
+    if (Array.isArray(keyword)) {
+        // if the keyword is an array, loop over all keywords and get the example lesson for each one
+        for (var i = 0; i < keyword.length; i++) {
+            const exampleJSON = getExampleLesson(keyword[i]);
+            exampleJSONs.push(exampleJSON);
+        }
+        return exampleJSONs.join(", ");
+    }
+    else {
+        // if the keyword is a string, get the example lesson for that keyword
+        const exampleJSON = getSingleExampleLesson(keyword);
+        if (exampleJSON) {
+            return exampleJSON;
+        }
+    }
+    // if no keywords match, return an empty string
+    return "";
+};
+const getSingleExampleLesson = (keyword) => {
+    // loop over all keywords and find the first one that matches
+    for (var i = 0; i < keywordsToExampleMap.length; i++) {
+        const keywordMap = keywordsToExampleMap[i];
+        if (keywordMap.keywords.includes(keyword)) {
+            return JSON.stringify(keywordMap.actions);
+        }
+    }
+    // if no keywords match, return an empty string
+    return "";
+};
+
+// Load environment variables from .env file
+dotenv.config();
+const ActionSchema = z.object({
+    name: z.string(),
+    value: z.string()
+});
+const CourseSnapshotSchema = z.object({});
+const LessonSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string(),
+    actions: z.array(ActionSchema),
+    initialSnapshot: CourseSnapshotSchema,
+    finalSnapshot: CourseSnapshotSchema
+});
+const CourseSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string(),
+    primaryLanguage: z.string(),
+    lessons: z.array(LessonSchema)
+});
+const server = new McpServer({
+    name: "codevideo-mcp",
+    version: version,
+    env: {
+        // preserve existing environment variables
+        ...Object.fromEntries(Object.entries(process.env)
+            .filter(([, value]) => value !== undefined)
+            .map(([key, value]) => [key, value])),
+        MCP_TIMEOUT: String(1200000), // 20 min - needed for video creation waiting
+    }
+});
+// Commenting out prompts and resources that aren't showing up 
+// - does Claude just use them internally?
+/*
+// add prompts
+server.prompt(
+    "codevideo_create_lesson",
+    { additionalContext: z.string() },
+    ({ additionalContext }) => ({
+        messages: [{
+            role: "user",
+            content: {
+                type: "text",
+                text: createLesson(additionalContext)
+            }
+        }]
+    })
+);
+
+// add resources
+server.resource(
+    "codevideo_get_action_names",
+    "codevideo_get_action_names://codevideo_get_action_names",
+    (uri) => ({
+        contents: [{
+            uri: uri.href,
+            text: getActionNames()
+        }]
+    })
+);
+
+server.resource(
+    "codevideo_get_example_lesson",
+    new ResourceTemplate("codevideo_get_example_lesson://{keyword}", { list: undefined }),
+    async (uri, { keyword }) => ({
+        contents: [{
+            uri: uri.href,
+            text: getExampleLesson(keyword)
+        }]
+    })
+);
+*/
+server.tool("codevideo_instructions_to_create_a_course", {
+    additionalContext: z.string()
+}, async ({ additionalContext }) => {
+    return {
+        content: [{
+                type: "text",
+                text: instructionsToCreateACourse(additionalContext)
+            }]
+    };
+});
+server.tool("codevideo_instructions_to_create_lesson_actions", {
+    additionalContext: z.string()
+}, async ({ additionalContext }) => {
+    return {
+        content: [{
+                type: "text",
+                text: instructionsToCreateLessonActions(additionalContext)
+            }]
+    };
+});
+server.tool("codevideo_instructions_to_create_lesson_video", {
+    additionalContext: z.string()
+}, async ({ additionalContext }) => {
+    return {
+        content: [{
+                type: "text",
+                text: instructionsToCreateLessonVideo(additionalContext)
+            }]
+    };
+});
+server.tool("codevideo_get_empty_lesson_snapshot", {}, async () => {
+    return {
+        content: [{
+                type: "text",
+                text: getEmptyLessonSnapshot()
+            }]
+    };
+});
+server.tool("codevideo_create_course_with_initial_metadata", {
+    id: z.string(),
+    name: z.string(),
+    description: z.string(),
+    primaryLanguage: z.string()
+}, async ({ id, name, description, primaryLanguage }) => {
+    return {
+        content: [{
+                type: "text",
+                text: createCourseWithInitialMetadata(id, name, description, primaryLanguage)
+            }]
+    };
+});
+server.tool("codevideo_add_actions_to_lesson", {
+    lesson: LessonSchema,
+    actions: z.array(ActionSchema)
+}, async ({ lesson, actions }) => {
+    // Cast the lesson to ILesson
+    const typedLesson = lesson;
+    // Cast the actions to IAction
+    const typedActions = actions;
+    return {
+        content: [{
+                type: "text",
+                text: addActionsToLesson(typedLesson, typedActions)
+            }]
+    };
+});
+server.tool("codevideo_get_final_lesson_snapshot", "Get the final state snapshot after applying CodeVideo actions. Pass actions array OR use previously stored actions from codevideo_set_current_actions (recommended workflow).", {
+    actions: z.array(ActionSchema).optional().describe("Array of CodeVideo actions to apply. Optional if actions were previously stored with codevideo_set_current_actions")
+}, async ({ actions }) => {
+    // Cast the actions to IAction if provided
+    const typedActions = actions;
+    return {
+        content: [{
+                type: "text",
+                text: getFinalLessonSnapshot(typedActions)
+            }]
+    };
+});
+server.tool("codevideo_add_lesson_to_course", {
+    course: CourseSchema,
+    id: z.string(),
+    name: z.string(),
+    description: z.string()
+}, async ({ course, id, name, description }) => {
+    // Cast the course to ICourse
+    const typedCourse = course;
+    return {
+        content: [{
+                type: "text",
+                text: addLessonToCourse(typedCourse, id, name, description)
+            }]
+    };
+});
+server.tool("codevideo_get_action_names", {}, async () => {
+    return {
+        content: [{
+                type: "text",
+                text: getActionNames()
+            }]
+    };
+});
+server.tool("codevideo_get_example_lesson", {
+    keyword: z.string()
+}, async ({ keyword }) => {
+    return {
+        content: [{
+                type: "text",
+                text: getExampleLesson(keyword)
+            }]
+    };
+});
+server.tool("codevideo_get_initial_lesson_state_from_local_repo", {
+    repoLocation: z.string()
+}, async ({ repoLocation }) => {
+    return {
+        content: [{
+                type: "text",
+                text: await getInitialLessonStateFromLocalCodebase(repoLocation)
+            }]
+    };
+});
+server.tool("codevideo_make_blog_post", "Generate a markdown blog post from CodeVideo actions. Pass actions array OR use previously stored actions from codevideo_set_current_actions (recommended workflow).", {
+    actions: z.array(ActionSchema).optional().describe("Array of CodeVideo actions. Optional if actions were previously stored with codevideo_set_current_actions")
+}, async ({ actions }) => {
+    // Cast the actions to IAction if provided
+    const typedActions = actions;
+    return {
+        content: [{
+                type: "text",
+                text: makeBlogPost(typedActions)
+            }]
+    };
+});
+server.tool("codevideo_make_html_web_page", "Generate an HTML web page from CodeVideo actions. Pass actions array OR use previously stored actions from codevideo_set_current_actions (recommended workflow).", {
+    actions: z.array(ActionSchema).optional().describe("Array of CodeVideo actions. Optional if actions were previously stored with codevideo_set_current_actions")
+}, async ({ actions }) => {
+    // Cast the actions to IAction if provided
+    const typedActions = actions;
+    return {
+        content: [{
+                type: "text",
+                text: await makeHTMLWebPage(typedActions)
+            }]
+    };
+});
+server.tool("codevideo_make_video", "Generate a video from CodeVideo actions. Pass actions array OR use previously stored actions from codevideo_set_current_actions (recommended workflow).", {
+    actions: z.array(ActionSchema).optional().describe("Array of CodeVideo actions. Optional if actions were previously stored with codevideo_set_current_actions")
+}, async ({ actions }) => {
+    // Cast the actions to IAction if provided
+    const typedActions = actions;
+    try {
+        const result = await makeVideo(typedActions);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        outputPath: result.outputPath,
+                        stdout: result.stdout,
+                        stderr: result.stderr
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        console.error('Error making video:', error);
+        // If the error has the VideoResult structure
+        if (error && typeof error === 'object' && 'stdout' in error && 'stderr' in error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error creating video: ${error.error?.message || String(error.error)}\nstdout: ${error.stdout}\nstderr: ${error.stderr}`
+                    }]
+            };
+        }
+        // Fall back to simple error message
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error creating video: ${error?.message || String(error)}`
+                }]
+        };
+    }
+});
+server.tool("codevideo_validate_actions", {
+    actions: z.array(ActionSchema).optional()
+}, async ({ actions }) => {
+    // Cast the actions to IAction if provided
+    const typedActions = actions;
+    return {
+        content: [{
+                type: "text",
+                text: validateActions(typedActions)
+            }]
+    };
+});
+server.tool("codevideo_is_repeatable_action", {
+    action: ActionSchema
+}, async ({ action }) => {
+    // Cast the action to IAction
+    const typedAction = action;
+    return {
+        content: [{
+                type: "text",
+                text: isRepeatable(typedAction)
+            }]
+    };
+});
+server.tool("codevideo_critique_video_using_gemini", "Critique a generated video using Google Gemini AI. Pass actions array OR use previously stored actions from codevideo_set_current_actions (recommended workflow).", {
+    videoPath: z.string().describe("Path to the video file to critique"),
+    actions: z.array(ActionSchema).optional().describe("Array of CodeVideo actions used to generate the video. Optional if actions were previously stored with codevideo_set_current_actions")
+}, async ({ videoPath, actions }) => {
+    // Cast the actions to IAction if provided
+    const typedActions = actions;
+    try {
+        const critique = await critiqueVideoUsingGemini(videoPath, typedActions);
+        return {
+            content: [{
+                    type: "text",
+                    text: critique
+                }]
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error("Error critiquing video:", errorMessage);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error critiquing video: ${errorMessage}`
+                }]
+        };
+    }
+});
+server.tool("codevideo_set_current_actions", "Store actions in local SQLite database for reuse across multiple tool calls. Once set, other tools can be called without re-specifying actions.", {
+    actions: z.array(ActionSchema).describe("Array of CodeVideo actions to store for later use")
+}, async ({ actions }) => {
+    // Cast the actions to IAction
+    const typedActions = actions;
+    return {
+        content: [{
+                type: "text",
+                text: setCurrentActions(typedActions)
+            }]
+    };
+});
+server.tool("codevideo_get_current_actions", "Retrieve the currently stored actions from local database. Use this to inspect what actions were previously set with codevideo_set_current_actions.", {}, async () => {
+    const actions = getCurrentActions();
+    if (!actions) {
+        return {
+            content: [{
+                    type: "text",
+                    text: "No actions found in storage. Use codevideo_set_current_actions first to store actions."
+                }]
+        };
+    }
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(actions, null, 2)
+            }]
+    };
+});
+// start the server
+const transport = new StdioServerTransport();
+(async () => {
+    await server.connect(transport);
+})();