flow-frame-core 0.1.0

package/dist/standardRoutes.js

@@ -0,0 +1,1495 @@
+import { exec, spawn } from 'child_process';
+import { getItem, setItem } from "./storage.js";
+import express from 'express';
+import { MIDJOURNEY_SELECTOR, getDownloadsFolder, moveSocialPorterVideos, findSocialPorterVideos, unzip, readProjectFile, getContext, saveProjectFile, findFilesWithString, findExplorerWindowPosition, getDetectOrientation, readJsonFiles, get, getMode, get_jobs_path, set, findJobs, findVideoJobs, getJobsContext, selectRandom, sanitizeFileName, downloadFile, extractFileNameFromUrl, getVideoDuration, findFileInDirectoryHasInWithAndEndingWith, alignLinesToWords, getLastModifiedTimestampSync, unique, processSunoState, getMediaFileDuration, getFilesToProcess, pause, getVideoDimensions, } from "./utils.js";
+import path from 'path';
+import queue from './queueManager.js';
+import fs from 'fs';
+import serveStatic from 'serve-static';
+import { downloadSunosWithPython } from "./suno_download.js";
+import { processFile, fix, toggleEndCuts } from "./process.js";
+import { operateSunoFilmMouse, operateSunoMouse, operateYoutubeMouse, clearMidjourneyImages, operateMidjourneyToImages, operateMidjourneyDownloadMedia, operateMidjourneyDownloadPublicMedia, operateMouse } from "./operations.js";
+import { getPeerConstants } from "./peers.js";
+import { captureFullScreenshot } from "./inference/capturescreenshot.js";
+import { runImagePromptGrok } from "./services/runPrompt.js";
+import { KEYS } from './constants.js';
+import { processAudio } from './services/audioService.js';
+import { generateTextFromTemplate } from './services/variableGenerator.js';
+import { buildWorkflowDirectory, runWorkflowCLI, installDependencies } from './services/workflow/build-workflow.js';
+import { scanExtensions } from './extensionUtils.js';
+import { recognizeScreen } from './services/self-learning/recognize.js';
+import { generateUIMap } from './services/uiMapService.js';
+const utils = { getJobsContext, unique };
+const jobs_context = getJobsContext();
+const input_bar = '[id="desktop_input_bar"]';
+// Define PROCEDURES if not imported from constants
+const PROCEDURES = {
+    MUSIC_VIDEOS: 'MUSIC_VIDEOS'
+};
+export function registerRoutes(app) {
+    app.post('/generate-audio', async (req, res) => {
+        const { text, voice, filePath, keepExisting } = req.body;
+        try {
+            if (!text || !voice || !filePath) {
+                res.status(400).json({ success: false, error: "Missing required parameters" });
+                return;
+            }
+            let { audioPath, srtPath } = await processAudio(filePath, text, voice, keepExisting);
+            res.json({ success: true, audioPath, srtPath });
+        }
+        catch (error) {
+            console.error('Error generating audio:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    app.post('/readDir', async (req, res) => {
+        try {
+            const { dirPath, depth = 1, fullpaths = false } = req.body;
+            if (!dirPath) {
+                res.status(400).json({ success: false, error: "dirPath is required" });
+                return;
+            }
+            const getFiles = async (dir, level) => {
+                const dirents = await fs.promises.readdir(dir, { withFileTypes: true });
+                const files = await Promise.all(dirents.map(async (dirent) => {
+                    const res = path.resolve(dir, dirent.name);
+                    const itemPath = fullpaths ? res : (depth > 1 ? path.relative(dirPath, res) : dirent.name);
+                    if (dirent.isDirectory() && level < depth) {
+                        const children = await getFiles(res, level + 1);
+                        return [itemPath, ...children];
+                    }
+                    return itemPath;
+                }));
+                return files.flat();
+            };
+            const files = await getFiles(dirPath, 1);
+            res.json({ success: true, files });
+        }
+        catch (error) {
+            console.error('Error reading directory:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    app.post('/readFiles', async (req, res) => {
+        try {
+            const { filePaths } = req.body;
+            if (!filePaths || !Array.isArray(filePaths)) {
+                res.status(400).json({ success: false, error: "filePaths array is required" });
+                return;
+            }
+            const results = {};
+            await Promise.all(filePaths.map(async (filePath) => {
+                try {
+                    const content = await fs.promises.readFile(filePath, 'utf-8');
+                    results[filePath] = content;
+                }
+                catch (error) {
+                    results[filePath] = { error: error.message };
+                }
+            }));
+            res.json({ success: true, results });
+        }
+        catch (error) {
+            console.error('Error reading files:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    app.post('/get-video-dimensions', async (req, res) => {
+        try {
+            const { filePath, filePaths } = req.body;
+            if (filePaths && Array.isArray(filePaths)) {
+                const results = {};
+                await Promise.all(filePaths.map(async (fp) => {
+                    try {
+                        const dims = await getVideoDimensions(fp);
+                        results[fp] = dims;
+                    }
+                    catch (err) {
+                        results[fp] = { error: err.message };
+                    }
+                }));
+                res.json(results);
+                return;
+            }
+            if (!filePath) {
+                res.status(400).json({ success: false, error: "filePath or filePaths is required" });
+                return;
+            }
+            const dimensions = await getVideoDimensions(filePath);
+            res.json({ success: true, ...dimensions });
+        }
+        catch (error) {
+            console.error('Error getting video dimensions:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    app.post('/generate-text-from-template', async (req, res) => {
+        try {
+            const { template, entities, options = {} } = req.body || {};
+            if (typeof template !== 'string' || !template.trim()) {
+                res.status(400).json({ success: false, error: 'template is required' });
+                return;
+            }
+            if (!Array.isArray(entities) || entities.length === 0) {
+                res.status(400).json({ success: false, error: 'entities must be a non-empty array' });
+                return;
+            }
+            const result = await generateTextFromTemplate(template, entities, options);
+            res.json({ success: true, ...result });
+        }
+        catch (error) {
+            console.error('Error generating text from template:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    app.get('/getSelectors', (req, res) => {
+        // Customize the selectors as needed.
+        console.log(getMode(), 'mode');
+        switch (getMode()) {
+            case MODES.SUNO:
+            case MODES.SUNO_FILM:
+                res.json({
+                    selectors: Object.values(SUNO_SELECTORS)
+                });
+                break;
+            case MODES.YOUTUBE:
+                res.json({
+                    selectors: Object.values(YOUTUBE_SELECTORS)
+                });
+                break;
+            case MODES.CLEAR_MIDJOURNEY_IMAGES:
+                res.json({
+                    selectors: Object.values(MIDJOURNEY_SELECTOR)
+                });
+                break;
+            case MODES.MIDJOURNEY:
+            default:
+                res.json({
+                    selectors: Object.values(MIDJOURNEY_SELECTOR)
+                });
+                break;
+        }
+    });
+    app.get('/send-element-selectors', (req, res) => {
+        // Implement the logic to find element selectors
+        if (req.body.selectors) {
+            let currentSelectors = get(KEYS.element_selectors) || [];
+            currentSelectors = unique([...currentSelectors, req.body], (e) => e.tabId);
+            set(KEYS.element_selectors, currentSelectors);
+            res.json({
+                success: true
+            });
+        }
+        else {
+            res.status(400).json({ error: 'Selectors are required' });
+        }
+    });
+    app.get('/get-list-selectors', (req, res) => {
+        // Customize the selectors as needed.
+        switch (getMode()) {
+            case MODES.SUNO:
+            case MODES.SUNO_FILM:
+                let suno_current_name = getItem('suno_current_name');
+                if (suno_current_name) {
+                    res.json({
+                        selectors: getContext().list_selectors || []
+                    });
+                    return;
+                }
+                break;
+            default:
+                break;
+        }
+        res.json({ selectors: [] });
+    });
+    app.post('/attach-suno-songs', async (req, res) => {
+        let current_song = get(KEYS.current_song_name);
+        let source_file_path = path.join(get(KEYS.current_folder), getItem('sourceFile'));
+        if (fs.existsSync(source_file_path)) {
+            if (current_song) {
+                let sourceJson = readProjectFile(source_file_path);
+                let projectData = sourceJson.find(v => v.name === current_song || v.original_name === current_song);
+                if (projectData) {
+                    projectData.lyrics = get(KEYS.song_lyrics);
+                    projectData.song_sources = get(KEYS.song_list);
+                    saveProjectFile(source_file_path, sourceJson);
+                }
+            }
+        }
+        res.json({ ok: true });
+    });
+    app.post('/downloadSunosWithPython', async (req, res) => {
+        await downloadSunosWithPython(get(KEYS.sunoDownloadFolder));
+        res.json({ ok: true });
+    });
+    app.post('/fetch-100-name', async (req, res) => {
+        const { description } = req.body;
+        let ressulo = await generateListOfName(description);
+        try {
+            return res.json({
+                res: JSON.stringify(extractJSONFromFence(ressulo))
+            });
+        }
+        catch (e) {
+            return res.json({
+                res: '[]'
+            });
+        }
+    });
+    // build an initial middleware
+    let staticMiddleware;
+    setImageFolder();
+    // mount a wrapper
+    app.use('/images', (req, res, next) => {
+        staticMiddleware(req, res, next);
+    });
+    let staticWebMiddleware = serveStatic(path.join('midjourney', 'html'));
+    app.use('/web', (req, res, next) => {
+        staticWebMiddleware(req, res, next);
+    });
+    // whenever you need to switch folders at runtime:
+    function setImageFolder() {
+        if (get(KEYS.images_folder))
+            staticMiddleware = serveStatic(get(KEYS.images_folder));
+    }
+    app.get('/project', (req, res) => {
+        let project_file = path.join(get(KEYS.current_folder), get(KEYS.sourceFile));
+        console.log(project_file);
+        let ces = readProjectFile(project_file);
+        console.log('getting:  jobs');
+        res.json(ces);
+    });
+    Object.values(KEYS).map((param) => {
+        app.post('/set-' + param, (req, res) => {
+            console.log(`[[set]] ${param}`, 'set-param');
+            console.log(` ${req.body[param]}`);
+            set(param, req.body[param]);
+            if (KEYS.images_folder === param) {
+                setImageFolder();
+            }
+            else if (KEYS.procedure === param) {
+            }
+            else if (KEYS.sourceFile) {
+                getContext().sourceFile = req.body[param];
+                let filePath = path.join(get(KEYS.current_folder) || '', get(KEYS.sourceFile) || '');
+                if (fs.existsSync(filePath) && (KEYS.sourceFile === param || KEYS.current_folder === param)) {
+                    let data = readProjectFile(filePath);
+                    set(KEYS.project_names, data.filter(x => x).map(v => v.name));
+                    const mySet = new Set(data
+                        .filter(x => x)
+                        .map(x => (x.characters || []).filter(c => c)).flat());
+                    set(KEYS.project_characters, Array.from(mySet));
+                }
+            }
+            if (KEYS.suno_state === param) {
+                let suno_state = get(KEYS.suno_state);
+                try {
+                    let project_song_states = [];
+                    let all_project_songs_ready = true;
+                    let song_states = [];
+                    let output_path = path.join(get(KEYS.current_folder), getItem('sourceFile'));
+                    let projects = readProjectFile(output_path);
+                    if (false)
+                        projects.forEach((project, index) => {
+                            ({
+                                suno_state, project_song_states, all_project_songs_ready, song_states
+                            } = processSunoState(suno_state, project_song_states, project, all_project_songs_ready, song_states));
+                        });
+                    saveProjectFile(output_path, projects);
+                }
+                catch (e) {
+                    console.log(`Error processing suno_state: ${e.message}`, 'suno_state error');
+                }
+            }
+            return res.json({
+                [param]: req.body[param]
+            });
+        });
+        app.get('/get-' + param, (req, res) => {
+            res.json({ [param]: get(param) });
+        });
+        app.get('/get-options-' + param, (req, res) => {
+            switch (param) {
+                case 'firstVideoForUpload':
+                    let filePath = path.join(get(KEYS.current_folder) || '', get(KEYS.sourceFile) || '');
+                    if (fs.existsSync(filePath)) {
+                        let data = readProjectFile(filePath);
+                        res.json(data.map(v => v.name));
+                        return;
+                    }
+                default:
+                    res.json(get(KEYS.project_characters));
+                    return;
+            }
+            res.json([]);
+        });
+    });
+    app.post('/setObject', (req, res) => {
+        set(req.body.key, req.body.value);
+        return res.json({
+            [req.body.key]: get(req.body.key)
+        });
+    });
+    app.post('/getObject', (req, res) => {
+        return res.json({
+            [req.body.key]: get(req.body.key)
+        });
+    });
+    app.post('/set-file-name', (req, res) => {
+        const { name } = req.body;
+        getContext().sourceFile = name;
+        setItem('sourceFile', name);
+        console.log(`getContext().sourceFile: ${getContext().sourceFile}`);
+        res.json({ ok: true });
+    });
+    app.post('/process-file', async (req, res) => {
+        const { name } = req.body;
+        let root_folder = get(KEYS.current_folder);
+        let filesToProcess = [name];
+        filesToProcess = getFilesToProcess(name, filesToProcess, root_folder);
+        filesToProcess.map((fileToProcess) => {
+            let temp = path.join(root_folder, fileToProcess);
+            console.log(`process file : ${temp}`);
+            if (fs.existsSync(temp) && temp.endsWith('.json')) {
+                processFile(temp, get_jobs_path(), name);
+                console.log(`processed`);
+            }
+        });
+        res.json({ ok: true });
+    });
+    app.post('/toggle-end-cuts', async (req, res) => {
+        const { name } = req.body;
+        let root_folder = get(KEYS.current_folder);
+        let fileToProcess = path.join(get(KEYS.current_folder), name);
+        let filesToProcess = [fileToProcess];
+        filesToProcess = getFilesToProcess(name, filesToProcess, root_folder);
+        console.log(`toggle-end-cuts : ${fileToProcess}`);
+        if (name)
+            filesToProcess.map((fileToProcess) => {
+                if (fs.existsSync(fileToProcess)) {
+                    toggleEndCuts(path.join(fileToProcess));
+                    console.log(`toggle-end-cuts complete`);
+                }
+            });
+        res.json({ ok: true });
+    });
+    app.get('/get-file-name', (req, res) => {
+        res.json({ name: getContext().sourceFile });
+    });
+    app.post('/select_song_sources', (req, res) => {
+        const { projectIndex, selectedSongSources } = req.body;
+        let project_file = path.join(get(KEYS.current_folder), get(KEYS.sourceFile));
+        let ces = readProjectFile(project_file);
+        ces[projectIndex].selected_song_sources = selectedSongSources;
+        saveProjectFile(project_file, ces);
+        res.json(ces);
+    });
+    app.post('/align-text', (req, res) => {
+        const {} = req.body;
+        let project_file = path.join(get(KEYS.current_folder), get(KEYS.sourceFile));
+        let ces = readProjectFile(project_file);
+        for (let projectIndex = 0; projectIndex < ces.length; projectIndex++) {
+            ces[projectIndex].processed_lyrics = (ces[projectIndex].lyrics || []).map((lyric, index) => {
+                const { alignedWords } = lyric;
+                return alignLinesToWords(alignedWords);
+            });
+        }
+        saveProjectFile(project_file, ces);
+    });
+    app.post('/select_image', (req, res) => {
+        const { projectIndex, lyricPromptIndex, imageName } = req.body;
+        let project_file = path.join(get(KEYS.current_folder), get(KEYS.sourceFile));
+        let ces = readProjectFile(project_file);
+        ces[projectIndex].selected_prompts = ces[projectIndex]?.selected_prompts || [];
+        // ces[projectIndex].lyrics.find(lyric => {
+        //     lyric.selected_prompts = lyric.selected_prompts || [];
+        //     return lyric.selected_prompts.includes(imageName);
+        // })
+        if (lyricPromptIndex !== undefined && lyricPromptIndex !== null) {
+            if (!ces[projectIndex].lyrics[lyricPromptIndex].selected_prompts) {
+                ces[projectIndex].lyrics[lyricPromptIndex].selected_prompts = [];
+            }
+            if (ces[projectIndex].lyrics[lyricPromptIndex].selected_prompts.includes(imageName)) {
+                ces[projectIndex].lyrics[lyricPromptIndex].selected_prompts = ces[projectIndex].lyrics[lyricPromptIndex].selected_prompts.filter(x => x !== imageName);
+            }
+            else {
+                ces[projectIndex].lyrics[lyricPromptIndex].selected_prompts.push(imageName);
+            }
+            if (!ces[projectIndex].lyrics[lyricPromptIndex].prompts_selection) {
+                ces[projectIndex].lyrics[lyricPromptIndex].prompts_selection = {};
+            }
+            ces[projectIndex].lyrics[lyricPromptIndex].prompts_selection[imageName] = imageName;
+        }
+        else {
+            if (ces[projectIndex].selected_prompts.includes(imageName)) {
+                ces[projectIndex].selected_prompts = ces[projectIndex].selected_prompts.filter(x => x !== imageName);
+            }
+            else {
+                ces[projectIndex].selected_prompts.push(imageName);
+            }
+        }
+        saveProjectFile(project_file, ces);
+        res.json(ces);
+    });
+    app.post('/clear_selected', async (req, res) => {
+        const {} = req.body;
+        let project_file = path.join(get(KEYS.current_folder), get(KEYS.sourceFile));
+        let ces = readProjectFile(project_file);
+        ces.map(item => {
+            item.selected_prompts = [];
+            item.prompts_selection = {};
+            item.selected_song_sources = [];
+            if (item?.lyrics) {
+                item?.lyrics.forEach(lyric => {
+                    if (lyric.prompts) {
+                        lyric.selected_prompts = [];
+                        lyric.prompts_selection = {};
+                    }
+                });
+            }
+        });
+        saveProjectFile(project_file, ces);
+        res.json(ces);
+    });
+    app.post('/select_random_image', async (req, res) => {
+        console.log(`[running]`, 'select_random_image');
+        const { count = 1 } = req.body;
+        let project_file = path.join(get(KEYS.current_folder), get(KEYS.sourceFile));
+        let ces = readProjectFile(project_file);
+        console.log(`${project_file}, count: ${count}`, 'project_file');
+        jobs_context.jobs = fs.readFileSync(get_jobs_path(), 'utf-8').split('\n').map(v => JSON.parse(v));
+        for (let j = 0; j < ces.length; j++) {
+            let item = ces[j];
+            if (item?.song_sources) {
+                for (let i = 0; i < item.song_sources.length; i++) {
+                    let filename = extractFileNameFromUrl(item.song_sources[i]);
+                    let audioFilePath = path.join(get(KEYS.audio_folder), sanitizeFileName(item.name), filename);
+                    if (!fs.existsSync(audioFilePath))
+                        await downloadFile(item.song_sources[i], audioFilePath, (output, progress) => {
+                            console.log(`${output}: ${progress}%`);
+                        });
+                }
+            }
+        }
+        ces.map(item => {
+            item.selected_prompts = item.selected_prompts || [];
+            item.prompts_selection = item.prompts_selection || {};
+            item.selected_song_sources = item.selected_song_sources || [];
+            item.selected_song_sources = item.selected_song_sources.filter(t => t);
+            if (!item.selected_song_sources.length) {
+                item.selected_song_sources.push(...selectRandom(item.song_sources || [], 10));
+            }
+            if (item.prompts)
+                item.prompts.map((prompt, promptIndex) => {
+                    let imageFiles = getImageFilesByPrompt(prompt, get(KEYS.ratio));
+                    if (imageFiles?.length) {
+                        if (!imageFiles.find(x => item.selected_prompts.includes(x))) {
+                            let rando = selectRandom(imageFiles, count);
+                            if (rando) {
+                                item.prompts_selection[prompt] = [...rando];
+                                item.selected_prompts.push(...rando);
+                            }
+                        }
+                    }
+                });
+            if (item.lyrics) {
+                item.lyrics.forEach(item => selectRandomLyricImages(item, count));
+            }
+            let imageFiles = getImageFilesByPrompt(item.portrait_prompt, get(KEYS.ratio));
+            if (imageFiles?.length) {
+                if (!imageFiles.find(x => item.selected_prompts.includes(x))) {
+                    let rando = selectRandom(imageFiles, count);
+                    if (rando) {
+                        item.selected_prompts.push(...rando);
+                        item.prompts_selection[item.portrait_prompt] = [...rando];
+                    }
+                }
+            }
+        });
+        saveProjectFile(project_file, ces);
+        console.log(`[done]`, 'select_random_image');
+        res.json(ces);
+    });
+    function selectRandomLyricImages(item, count) {
+        if (item.prompts) {
+            item.selected_prompts = item.selected_prompts || [];
+            item.prompts_selection = item.prompts_selection || {};
+            item.prompts.map(prompt => {
+                let imageFiles = getImageFilesByPrompt(prompt, get(KEYS.ratio));
+                if (imageFiles?.length) {
+                    if (!imageFiles.find(x => item.selected_prompts.includes(x))) {
+                        let rando = selectRandom(imageFiles, count);
+                        if (rando) {
+                            item.selected_prompts.push(...rando);
+                            item.prompts_selection[prompt] = [...rando];
+                        }
+                    }
+                }
+            });
+        }
+    }
+    app.post('/image_to_video', (req, res) => {
+        const { projectIndex, imageName } = req.body;
+        let project_file = path.join(get(KEYS.current_folder), get(KEYS.sourceFile));
+        let ces = readProjectFile(project_file);
+        ces[projectIndex].converting_prompts = ces[projectIndex]?.converting_prompts || [];
+        if (ces[projectIndex].converting_prompts.includes(imageName)) {
+            ces[projectIndex].converting_prompts = ces[projectIndex].converting_prompts.filter(x => x !== imageName);
+        }
+        else {
+            ces[projectIndex].converting_prompts.push(imageName);
+        }
+        saveProjectFile(project_file, ces);
+        res.json(ces);
+    });
+    app.post('/getAudioDurations', async (req, res) => {
+        const { audioFiles, videos } = req.body;
+        let results = {};
+        for (let i = 0; i < audioFiles.length; i++) {
+            let audioFilePath = audioFiles[i];
+            if (fs.existsSync(audioFilePath)) {
+                results[audioFilePath] = await getMediaFileDuration(audioFilePath);
+            }
+        }
+        for (let i = 0; i < videos.length; i++) {
+            let videoFilePath = videos[i];
+            if (fs.existsSync(videoFilePath)) {
+                results[videoFilePath] = await getMediaFileDuration(videoFilePath);
+            }
+        }
+        res.json(results);
+    });
+    app.post('/downloadAudio', async (req, res) => {
+        console.log(`[running]`, 'downloadAudio');
+        const {} = req.body;
+        let project_file = path.join(get(KEYS.current_folder), get(KEYS.sourceFile));
+        let ces = readProjectFile(project_file);
+        console.log(`${project_file}`, 'project_file');
+        jobs_context.jobs = fs.readFileSync(get_jobs_path(), 'utf-8').split('\n').map(v => JSON.parse(v));
+        for (let j = 0; j < ces.length; j++) {
+            let item = ces[j];
+            item.song_sources_information = item.song_sources_information || [];
+            if (item?.song_sources) {
+                for (let i = 0; i < item.song_sources.length; i++) {
+                    let filename = extractFileNameFromUrl(item.song_sources[i]);
+                    let audioFilePath = path.join(get(KEYS.audio_folder), sanitizeFileName(item.name), filename);
+                    if (!fs.existsSync(audioFilePath)) {
+                        await downloadFile(item.song_sources[i], audioFilePath, (output, progress) => {
+                        });
+                    }
+                    if (fs.existsSync(audioFilePath)) {
+                        let stats = fs.statSync(audioFilePath);
+                        let lastModified = getLastModifiedTimestampSync(audioFilePath);
+                        item.song_sources_information[i] = {
+                            url: item.song_sources[i],
+                            file: filename,
+                            size: stats.size,
+                            lastModified,
+                            duration: await getMediaFileDuration(audioFilePath)
+                        };
+                    }
+                }
+            }
+        }
+        saveProjectFile(project_file, ces);
+        console.log(`[done]`, 'downloadAudio');
+        res.json({ ok: true });
+    });
+    app.post('/processVideoJobs', async (req, res) => {
+        let project_file = path.join(get(KEYS.current_folder), get(KEYS.sourceFile));
+        let ces = readProjectFile(project_file);
+        console.log(`[running]`, 'processVideoJobs');
+        jobs_context.jobs = fs.readFileSync(get_jobs_path(), 'utf-8').split('\n').map(v => JSON.parse(v));
+        for (let j = 0; j < ces.length; j++) {
+            let item = ces[j];
+            if (item?.lyrics) {
+                for (let i = 0; i < item.lyrics.length; i++) {
+                    let lyric = item.lyrics[i];
+                    if (lyric.prompts_selection) {
+                        lyric.prompts_videos = lyric.prompts_videos || {};
+                        let promptKeys = Object.keys(lyric.prompts_selection);
+                        for (let k = 0; k < promptKeys.length; k++) {
+                            let prompt = promptKeys[k];
+                            let jobs = findVideoJobs(prompt);
+                            lyric.prompts_videos[prompt] = {};
+                            if (jobs) {
+                                console.log(`jobs: ${jobs?.length}`, 'jobs');
+                                for (let jobIndex = 0; jobIndex < jobs.length; jobIndex++) {
+                                    let job = jobs[jobIndex];
+                                    for (let i = 0; i < job.batch_size; i++) {
+                                        let file = findFileInDirectoryHasInWithAndEndingWith(get(KEYS.images_folder), `${job.id}_${i}`, '.mp4');
+                                        if (file) {
+                                            lyric.prompts_videos[prompt][job.id] = lyric.prompts_videos[prompt][job.id] || [];
+                                            let duration = await getVideoDuration(path.join(get(KEYS.images_folder), file)).then(duration => {
+                                                return duration;
+                                            });
+                                            lyric.prompts_videos[prompt][job.id].push({ file, ...duration });
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            let { prompts } = item;
+            if (prompts) {
+                for (let i = 0; i < prompts.length; i++) {
+                    let prompt = prompts[i];
+                    let jobs = findVideoJobs(prompt);
+                    item.prompts_videos = item.prompts_videos || {};
+                    item.prompts_videos[prompt] = {};
+                    if (jobs) {
+                        console.log(`jobs: ${jobs?.length}`, 'jobs');
+                        for (let jobIndex = 0; jobIndex < jobs.length; jobIndex++) {
+                            let job = jobs[jobIndex];
+                            for (let i = 0; i < job.batch_size; i++) {
+                                let file = findFileInDirectoryHasInWithAndEndingWith(get(KEYS.images_folder), `${job.id}_${i}`, '.mp4');
+                                if (file) {
+                                    item.prompts_videos[prompt][job.id] = item.prompts_videos[prompt][job.id] || [];
+                                    let duration = await getVideoDuration(path.join(get(KEYS.images_folder), file)).then(duration => {
+                                        return duration;
+                                    });
+                                    item.prompts_videos[prompt][job.id].push({ file, ...duration });
+                                    item.prompts_selection = item.prompts_selection || {};
+                                    item.prompts_selection[prompt] = item.prompts_selection[prompt] || [];
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        saveProjectFile(project_file, ces);
+        console.log(`[done]`, 'processVideoJobs');
+        res.json({ ok: true });
+    });
+    app.post('/take-screenshot', async (req, res) => {
+        await pause(() => { }, 1000); // wait for a second to ensure the screen is ready
+        const { appName } = req.body;
+        console.log(`[running]`, 'take-screenshot');
+        let filename = await captureFullScreenshot(path.join(get(KEYS.screen_shot_folder), `${appName}`));
+        res.json({
+            filename,
+            filePath: path.join(get(KEYS.screen_shot_folder), `${appName}`, filename)
+        });
+        console.log(`Screenshot saved as: ${filename}`, 'take-screenshot');
+        // console.log(`[done]`, 'take-screenshot');
+    });
+    app.post('/recognize-screen-signature', async (req, res) => {
+        const { filePath } = req.body;
+        console.log(`[running] recognize-screen-signature`, 'recognize-screen-signature');
+        try {
+            const result = await recognizeScreen(filePath);
+            console.log(`[done] recognize-screen-signature`, 'recognize-screen-signature');
+            res.json({ result });
+        }
+        catch (error) {
+            console.log(`Error in recognize-screen-signature: ${error.message}`, 'recognize-screen-signature-error');
+            res.status(500).json({ error: `Failed to recognize screen signature: ${error.message}` });
+        }
+    });
+    app.post('/analyze-image-grok', async (req, res) => {
+        try {
+            const { prompt, base64_image } = req.body;
+            // Validate inputs
+            if (!prompt || typeof prompt !== 'string' || prompt.trim().length === 0) {
+                return res.status(400).json({ error: 'Valid prompt is required' });
+            }
+            if (!base64_image || typeof base64_image !== 'string' || !base64_image.startsWith('data:image/')) {
+                return res.status(400).json({ error: 'Valid base64 image data URL is required' });
+            }
+            console.log(`[running] analyze-image-grok with prompt: ${prompt.substring(0, 50)}...`, 'analyze-image-grok');
+            const result = await runImagePromptGrok(prompt, base64_image);
+            console.log(`[done] analyze-image-grok`, 'analyze-image-grok');
+            res.json({ result });
+        }
+        catch (error) {
+            console.log(`Error in analyze-image-grok: ${error.message}`, 'analyze-image-grok-error');
+            res.status(500).json({ error: `Failed to analyze image: ${error.message}` });
+        }
+    });
+    app.post('/delete-files', async (req, res) => {
+        try {
+            const { filePaths } = req.body;
+            // Validate inputs
+            if (!Array.isArray(filePaths)) {
+                return res.status(400).json({ error: 'filePaths must be an array' });
+            }
+            if (filePaths.length === 0) {
+                return res.status(400).json({ error: 'filePaths array cannot be empty' });
+            }
+            console.log(`[running] delete-files for ${filePaths.length} files`, 'delete-files');
+            const results = [];
+            let deletedCount = 0;
+            let errorCount = 0;
+            for (const filePath of filePaths) {
+                try {
+                    if (typeof filePath !== 'string' || !filePath.trim()) {
+                        results.push({ filePath, success: false, error: 'Invalid file path' });
+                        errorCount++;
+                        continue;
+                    }
+                    // Check if file exists before attempting to delete
+                    if (fs.existsSync(filePath)) {
+                        fs.unlinkSync(filePath);
+                        results.push({ filePath, success: true });
+                        deletedCount++;
+                        console.log(`Deleted: ${filePath}`, 'delete-files');
+                    }
+                    else {
+                        results.push({ filePath, success: false, error: 'File not found' });
+                        errorCount++;
+                        console.log(`File not found: ${filePath}`, 'delete-files');
+                    }
+                }
+                catch (error) {
+                    results.push({ filePath, success: false, error: error.message });
+                    errorCount++;
+                    console.log(`Error deleting ${filePath}: ${error.message}`, 'delete-files-error');
+                }
+            }
+            console.log(`[done] delete-files - deleted: ${deletedCount}, errors: ${errorCount}`, 'delete-files');
+            res.json({
+                success: true,
+                total: filePaths.length,
+                deleted: deletedCount,
+                errors: errorCount,
+                results
+            });
+        }
+        catch (error) {
+            console.log(`Error in delete-files: ${error.message}`, 'delete-files-error');
+            res.status(500).json({ error: `Failed to delete files: ${error.message}` });
+        }
+    });
+    app.post('/clear-directory', async (req, res) => {
+        try {
+            const { directory } = req.body;
+            const directoryPath = directory;
+            // Validate inputs
+            if (!directoryPath || typeof directoryPath !== 'string') {
+                return res.status(400).json({ error: 'directoryPath must be a non-empty string' });
+            }
+            console.log(`[running] clear-directory for ${directoryPath}`, 'clear-directory');
+            // Check if directory exists
+            if (!fs.existsSync(directoryPath)) {
+                return res.status(404).json({ error: 'Directory not found' });
+            }
+            // Check if it's actually a directory
+            const stats = fs.statSync(directoryPath);
+            if (!stats.isDirectory()) {
+                return res.status(400).json({ error: 'Path is not a directory' });
+            }
+            // Read directory contents
+            const items = fs.readdirSync(directoryPath);
+            const results = [];
+            let deletedCount = 0;
+            let errorCount = 0;
+            for (const item of items) {
+                const itemPath = path.join(directoryPath, item);
+                try {
+                    // Only delete files, not subdirectories
+                    const itemStats = fs.statSync(itemPath);
+                    if (itemStats.isFile()) {
+                        fs.unlinkSync(itemPath);
+                        results.push({ filePath: itemPath, success: true });
+                        deletedCount++;
+                        console.log(`Deleted: ${itemPath}`, 'clear-directory');
+                    }
+                    else {
+                        results.push({ filePath: itemPath, success: false, error: 'Is a directory (skipped)' });
+                        console.log(`Skipped directory: ${itemPath}`, 'clear-directory');
+                    }
+                }
+                catch (error) {
+                    results.push({ filePath: itemPath, success: false, error: error.message });
+                    errorCount++;
+                    console.log(`Error deleting ${itemPath}: ${error.message}`, 'clear-directory-error');
+                }
+            }
+            console.log(`[done] clear-directory - deleted: ${deletedCount}, errors: ${errorCount}, total items: ${items.length}`, 'clear-directory');
+            res.json({
+                success: true,
+                directoryPath,
+                totalItems: items.length,
+                deleted: deletedCount,
+                errors: errorCount,
+                results
+            });
+        }
+        catch (error) {
+            console.log(`Error in clear-directory: ${error.message}`, 'clear-directory-error');
+            res.status(500).json({ error: `Failed to clear directory: ${error.message}` });
+        }
+    });
+    app.post('/getImages', (req, res) => {
+        const { prompt, lyricPrompt } = req.body;
+        let jobs = prompt.trim() ? findJobs(prompt) : [];
+        console.log(`jobs: ${jobs.length}/${jobs_context?.jobs?.length}`, 'jobs');
+        let imageFiles = jobs.map((job) => {
+            return findFilesWithString(get(KEYS.images_folder), job.id);
+        }).flat();
+        let ljobs = lyricPrompt?.trim() ? findJobs(lyricPrompt) : [];
+        console.log(`jobs: ${ljobs.length}/${jobs_context?.jobs?.length}`, 'jobs');
+        let limageFiles = ljobs.map((job) => {
+            return findFilesWithString(get(KEYS.images_folder), job.id);
+        }).flat();
+        res.json({ prompts: imageFiles, lyricPrompts: limageFiles });
+    });
+    app.get('/get-current-source', (req, res) => {
+        res.json({ name: getItem('sourceFile') });
+    });
+    function getImageFilesByPrompt(prompt, ratio) {
+        let jobs = jobs_context.jobs.filter(job => getDetectOrientation(job) === ratio).filter(f => `${f.full_command}`.includes(prompt));
+        let imageFiles = jobs.map((job) => {
+            if (ratio) {
+                let orientation = getDetectOrientation(job);
+                if (orientation === ratio) {
+                    jobs_context.jobDetails = jobs_context.jobDetails || {};
+                    if (job?.files?.[ratio]) {
+                        return job?.files?.[ratio];
+                    }
+                    let temp = findFilesWithString(get(KEYS.images_folder), job.id);
+                    job.files = job.files || {};
+                    job.files[ratio] = temp;
+                    temp.map(t => {
+                        if (!jobs_context?.jobDetails?.[t]) {
+                            jobs_context.jobDetails[t] = jobs_context.jobDetails[t] || {};
+                            job.orientation = getDetectOrientation(job);
+                            jobs_context.jobDetails[t].job = job;
+                        }
+                    });
+                    return temp;
+                }
+            }
+            return [];
+        }).flat();
+        console.log(`imageFiles: ${imageFiles.length}`, 'imageFiles');
+        return imageFiles;
+    }
+    app.post('/uploadVideos', async (req, res) => {
+        const folderAddress = "pouch";
+        const bounds = findExplorerWindowPosition(folderAddress);
+    });
+    app.post('/get-key-value', (req, res) => {
+        res.json({
+            value: get(req.body.key),
+            [req.body.key]: get(req.body.key)
+        });
+    });
+    app.post('/MJ_DATA_CAPTURED'.toLocaleLowerCase(), (req, res) => {
+        let messageBodySplit = req.body.data;
+        let processedBody = messageBodySplit.map(t => {
+            let v = (t);
+            if (!v.fixed || true) {
+                v.full_command = fix(v.full_command);
+                v.fixed = true;
+            }
+            return (v);
+        });
+        console.log(`${processedBody.length}`, 'processedBody');
+        let existingJobs = [];
+        try {
+            let content = fs.readFileSync(get_jobs_path(), 'utf-8');
+            let split_content = content.split('\n');
+            console.log(`${split_content.length}`, 'split_content.length');
+            console.log(`${get_jobs_path()}`, 'jobs');
+            existingJobs = split_content.map(d => {
+                return JSON.parse(d);
+            }).filter(x => newerThan(new Date(x.enqueue_time), 1000 * 60 * 60 * 24 * 45)).sort((a, b) => {
+                return new Date(b.enqueue_time) - new Date(a.enqueue_time); // sort by enqueue_time descending
+            }); // filter out jobs older than 45 days
+        }
+        catch (e) {
+            console.error(e);
+            existingJobs = [];
+        }
+        processedBody = unique([...processedBody, ...existingJobs], x => x.id);
+        fs.writeFileSync(get_jobs_path(), processedBody.map(t => JSON.stringify(t)).join('\n'));
+        jobs_context.jobs = processedBody;
+        console.log(`${jobs_context.jobs.length}`, 'jobs');
+        res.json({ great: true });
+    });
+    function newerThan(timestamp, duration) {
+        const now = Date.now();
+        return (now - timestamp) < duration;
+    }
+    app.post('/update-jobs', express.text({ type: 'text/plain', limit: '1110mb' }), (req, res) => {
+        let messageBodySplit = req.body.split('\n');
+        if (!req.body.trim()) {
+            res.json({ great: true });
+            return;
+        }
+        let processedBody = messageBodySplit.map(t => {
+            let v = JSON.parse(t);
+            if (!v.fixed) {
+                v.full_command = fix(v.full_command);
+                v.fixed = true;
+            }
+            return (v);
+        });
+        let existingJobs = [];
+        try {
+            let content = fs.readFileSync(get_jobs_path(), 'utf-8');
+            let split_content = content.split('\n');
+            existingJobs = split_content.map(d => {
+                return JSON.parse(d);
+            });
+        }
+        catch (e) {
+            console.error(e);
+            existingJobs = [];
+        }
+        processedBody = unique([...processedBody, ...existingJobs], x => x.id);
+        fs.writeFileSync(get_jobs_path(), processedBody.map(t => JSON.stringify(t)).join('\n'));
+        jobs_context.jobs = processedBody;
+        console.log('running:  writing jobs ' + jobs_context.jobs.length, 'jobs');
+        res.json({ great: true });
+    });
+    app.post('/jobs', express.text({ type: 'text/plain', limit: '1110mb' }), (req, res) => {
+        let processedBody = req.body.split('\n').map(t => {
+            let v = JSON.parse(t);
+            if (!v.fixed) {
+                v.full_command = fix(v.full_command);
+                v.fixed = true;
+            }
+            return JSON.stringify(v);
+        });
+        fs.writeFileSync(get_jobs_path(), processedBody.join('\n'));
+        jobs_context.jobs = processedBody.map(t => {
+            return JSON.parse(t);
+        });
+        console.log('running:  writing jobs ' + jobs_context.jobs.length, 'jobs');
+        res.json({ great: true });
+    });
+    app.post('/unzip', express.text({ type: 'text/plain' }), async (req, res) => {
+        console.log('running:  unzip');
+        try {
+            let folder = getDownloadsFolder();
+            await unzip(folder, get(KEYS.images_folder));
+            await findSocialPorterVideos()
+                .then(files => moveSocialPorterVideos(files, get(KEYS.images_folder)))
+                .catch(console.error);
+            res.send(`Script output:\n${stdout}`);
+        }
+        catch (error) {
+            res.status(500).send(`Error: ${error.message}`);
+        }
+    });
+    app.post('/unzipTopTen', express.text({ type: 'text/plain' }), async (req, res) => {
+        console.log('running:  unzip');
+        try {
+            let folder = getDownloadsFolder();
+            await unzip(folder, path.join(get(KEYS.images_folder), 'top_ten_videos'));
+            await findSocialPorterVideos()
+                .then(files => moveSocialPorterVideos(files, path.join(get(KEYS.images_folder), 'top_ten_videos')))
+                .catch(console.error);
+            res.send(`Script output:\n${stdout}`);
+        }
+        catch (error) {
+            res.status(500).send(`Error: ${error.message}`);
+        }
+    });
+    app.post('/update-positions', async (req, res) => {
+        getContext().positions = {};
+        console.log(`${new Date(Date.now()).toLocaleDateString()} ${new Date(Date.now()).toLocaleTimeString()}`, 'update-positions');
+        if ([
+            MODES.MIDJOURNEY_IMAGES_TO_VIDEO,
+            MODES.CLEAR_MIDJOURNEY_IMAGES,
+            MODES.MIDJOURNEY_DOWNLOAD_MEDIA,
+            MODES.MIDJOURNEY_DOWNLOAD_PUBLIC_MEDIA,
+            MODES.MIDJOURNEY
+        ].includes(getMode()) && req.body?.location?.includes("midjourney.com")) {
+            getContext().position[getMode()] = req.body;
+            console.log(JSON.stringify(getContext().position[getMode()], null, 3), 'position');
+        }
+        else if (getMode() === MODES.SUNO_FILM && req.body?.location?.includes("https://suno.com")) {
+            getContext().position[getMode()] = req.body;
+            console.log(JSON.stringify(getContext().position[getMode()], null, 3), 'position');
+        }
+        else if ([MODES.YOUTUBE].includes(getMode()) && req.body?.location?.includes(".youtube.com")) {
+            getContext().position[getMode()] = req.body;
+            console.log(JSON.stringify(getContext().position[getMode()], null, 3), 'position');
+        }
+        else if ([MODES.FLOW_FRAME].includes(getMode())) {
+            getContext().position[getMode()] = req.body;
+        }
+        else {
+            console.log('not setting position for mode: ' + getMode(), 'not-position');
+        }
+        console.log(req?.body?.location, 'location');
+        console.log(getMode(), 'mode');
+        res.json({ status: 'success' });
+    });
+    app.get('/', async (req, res) => {
+        res.json({ status: 'success' });
+    });
+    app.get('/get-projects', async (req, res) => {
+        let dir = get(KEYS.current_folder);
+        if (dir) {
+            let jsonFiles = await readJsonFiles(dir);
+            res.json({ projects: jsonFiles.map(jk => path.basename(jk)) });
+        }
+        else {
+            res.json({ projects: [] });
+        }
+    });
+    app.post('/broadcast-stories', async (req, res) => {
+        let dir = get(KEYS.current_folder);
+        const { peers, localIp, localKey } = getPeerConstants();
+        if (dir) {
+            let jsonFiles = await readJsonFiles(dir);
+            let urls = Array.from(peers).map(([_ts, key]) => {
+                return `http://${_ts}`;
+            });
+            for (let j = 0; j < jsonFiles.length; j++) {
+                let jsonFile = jsonFiles[j];
+                for (let i = 0; i < urls.length; i++) {
+                    let url = urls[i];
+                    if (url !== `http://${localKey}`) {
+                        console.log(path.basename(jsonFile), 'broadcasted file');
+                        console.log(url, 'broadcasted file url');
+                        let res = await fetch(`${url}/receive-broadcasted-stories`, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({
+                                fileName: path.basename(jsonFile),
+                                content: fs.readFileSync(jsonFile, 'utf-8'),
+                                last_updated: getLastModifiedTimestampSync(jsonFile)
+                            })
+                        });
+                        console.log((await res.text()), 'broadcasted file result');
+                        ;
+                    }
+                }
+            }
+        }
+        res.json({ status: 'success' });
+    });
+    app.post('/receive-broadcasted-stories', async (req, res) => {
+        console.log('received broadcast story');
+        const dir = get(KEYS.current_folder);
+        if (!dir) {
+            return res.status(400).json({ error: 'No target folder configured' });
+        }
+        // payload should be { fileName, content, last_updated }
+        const { fileName, content, last_updated } = req.body;
+        if (!fileName || !content || typeof last_updated !== 'number') {
+            console.log('received bad file : ' + fileName, 'received-file-status');
+            return res.status(400).json({ error: 'Invalid payload' });
+        }
+        const targetPath = path.join(dir, fileName);
+        let updated = false;
+        try {
+            if (fs.existsSync(targetPath)) {
+                console.log('overwriting : ' + targetPath, 'received-file-status');
+                // only overwrite if the incoming copy is newer
+                const localTs = getLastModifiedTimestampSync(targetPath);
+                if (last_updated > localTs) {
+                    fs.writeFileSync(targetPath, content, 'utf8');
+                    updated = true;
+                }
+            }
+            else {
+                // file doesn't exist yet, so write it
+                console.log('newfile : ' + targetPath, 'received-file-status');
+                fs.writeFileSync(targetPath, content, 'utf8');
+                updated = true;
+            }
+            // Optionally, sync the file mtime to the broadcasted timestamp:
+            fs.utimesSync(targetPath, new Date(), new Date(last_updated));
+            res.json({ status: 'ok', updated });
+        }
+        catch (err) {
+            console.log('Error in /receive-broadcasted-stories : ', 'received-file-status');
+            console.error('Error in /receive-broadcasted-stories:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    let promiseQueue = Promise.resolve();
+    // Endpoint to receive positions.
+    app.post('/positions', async (req, res) => {
+        const mode = getContext().mode;
+        const body = req.body;
+        try {
+            promiseQueue = promiseQueue.then(() => {
+                // wrap your various operations into the queue
+                switch (mode) {
+                    case MODES.SUNO:
+                        return operateSunoMouse(body);
+                    case MODES.SUNO_FILM:
+                        return operateSunoFilmMouse(body);
+                    case MODES.YOUTUBE:
+                        return operateYoutubeMouse(body);
+                    case MODES.CLEAR_MIDJOURNEY_IMAGES:
+                        return clearMidjourneyImages();
+                    case MODES.MIDJOURNEY_IMAGES_TO_VIDEO:
+                        return operateMidjourneyToImages();
+                    case MODES.MIDJOURNEY_DOWNLOAD_MEDIA:
+                        return operateMidjourneyDownloadMedia();
+                    case MODES.MIDJOURNEY_DOWNLOAD_PUBLIC_MEDIA:
+                        return operateMidjourneyDownloadPublicMedia();
+                    case MODES.MIDJOURNEY:
+                        return operateMouse((body[input_bar]));
+                }
+            }).catch(e => {
+                console.log('', 'mode-filter');
+                console.log(`Error in /positions: ${e.message}`, 'positions-error');
+            });
+            await promiseQueue;
+            console.log(`Operation for mode ${mode} completed successfully`, 'positions-success');
+            res.json({ status: 'success', message: 'Operation finished successfully' });
+            return;
+        }
+        catch (e) {
+            console.error(e);
+            // console.log(e, 'positions-error');
+            console.log(`Error in /positions: ${e.message}`, 'positions-error');
+            console.log(`Stack trace: ${e.stack}`, 'positions-error-stack');
+            res.status(500).json({ status: 'error', message: e.message });
+            return;
+        }
+    });
+    //  app.post('/positions', async (req, res) => {
+    //     const mode = getContext().mode;
+    //     const body = req.body;
+    //     try {
+    //         // wrap your various operations into the queue
+    //         const jobId = queue.enqueue((signal, progress) => {
+    //             switch (mode) {
+    //                 case MODES.SUNO:
+    //                     return operateSunoMouse(body, signal, progress);
+    //                 case MODES.SUNO_FILM:
+    //                     return operateSunoFilmMouse(body, signal, progress);
+    //                 case MODES.YOUTUBE:
+    //                     return operateYoutubeMouse(body, signal, progress);
+    //                 case MODES.CLEAR_MIDJOURNEY_IMAGES:
+    //                     return clearMidjourneyImages(signal, progress);
+    //                 case MODES.MIDJOURNEY_IMAGES_TO_VIDEO:
+    //                     return operateMidjourneyToImages(signal, progress)
+    //                 case MODES.MIDJOURNEY_DOWNLOAD_MEDIA:
+    //                     return operateMidjourneyDownloadMedia(signal, progress);
+    //                 case MODES.MIDJOURNEY_DOWNLOAD_PUBLIC_MEDIA:
+    //                     return operateMidjourneyDownloadPublicMedia(signal, progress);
+    //                 case MODES.MIDJOURNEY:
+    //                     return operateMouse((body[input_bar]), signal, progress);
+    //             }
+    //         });
+    //         let status = 'waiting';
+    //         await queue.waitForJobId(jobId, (info) => {
+    //             status = info.status;
+    //             if (info.status === 'done') {
+    //                 console.log(`Job ${jobId} completed successfully`, 'positions-success');
+    //             } else if (info.status === 'error') {
+    //                 console.log(`Job ${jobId} failed with error: ${info.error}`, '   positions-error');
+    //             }
+    //         });
+    //         res.json({ status, jobId });
+    //     } catch (e) {
+    //         console.error(e)
+    //         console.log(e, 'positions-error')
+    //     }
+    // });
+    app.get('/operations/:jobId/status', (req, res) => {
+        const info = queue.status(+req.params.jobId);
+        if (!info)
+            return res.status(404).json({ error: 'no such job' });
+        res.json(info);
+    });
+    app.post('/operations/:jobId/cancel', (req, res) => {
+        const ok = queue.cancel(+req.params.jobId);
+        res.json({ status: ok ? 'cancelling' : 'not found' });
+    });
+    // **list all jobs**
+    app.get('/operations', (req, res) => {
+        res.json(queue.list());
+    });
+    // Endpoint to receive positions.
+    app.post('/open-ai-positions', async (req, res) => {
+        res.json({ status: 'success' });
+        setOpenAiPositions(req.body);
+    });
+    app.post('/suno-urls', async (req, res) => {
+        const { urls, name } = req.body;
+        console.log(urls);
+    });
+    // Open application by name
+    app.post('/open-app', async (req, res) => {
+        const { appName } = req.body;
+        if (!appName) {
+            return res.status(400).json({ error: 'Application name is required' });
+        }
+        try {
+            if (process.platform === 'darwin') {
+                spawn('open', ['-a', appName], { detached: true, stdio: 'ignore' });
+            }
+            else if (process.platform === 'win32') {
+                spawn('cmd', ['/c', 'start', '""', appName], { detached: true, stdio: 'ignore' });
+            }
+            else {
+                return res.status(400).json({ error: 'Unsupported platform' });
+            }
+            console.log(`Successfully started ${appName}`, 'open-app-success');
+            res.json({ success: true, message: `${appName} started successfully` });
+        }
+        catch (e) {
+            console.log(`Exception starting ${appName}: ${e.message}`, 'open-app-error');
+            res.status(500).json({ error: `Exception: ${e.message}` });
+        }
+    });
+    // Close application by name
+    app.post('/close-app', async (req, res) => {
+        const { appName, force = false } = req.body;
+        if (!appName) {
+            return res.status(400).json({ error: 'Application name is required' });
+        }
+        let command;
+        if (process.platform === 'darwin') {
+            const killSignal = force ? '-KILL' : '-TERM';
+            command = `killall ${killSignal} "${appName}"`;
+        }
+        else if (process.platform === 'win32') {
+            const forceFlag = force ? '/F' : '';
+            command = `taskkill /IM "${appName}.exe" ${forceFlag}`;
+        }
+        else {
+            return res.status(400).json({ error: 'Unsupported platform' });
+        }
+        try {
+            exec(command, (error, stdout, stderr) => {
+                if (error) {
+                    console.log(`Error closing ${appName}: ${error.message}`, 'close-app-error');
+                    return res.status(404).json({ error: `Application not found or already closed: ${appName}` });
+                }
+                console.log(`Successfully closed ${appName}`, 'close-app-success');
+                res.json({ success: true, message: `${appName} closed successfully` });
+            });
+        }
+        catch (e) {
+            console.log(`Exception closing ${appName}: ${e.message}`, 'close-app-error');
+            res.status(500).json({ error: `Exception: ${e.message}` });
+        }
+    });
+    // Wait for file to stabilize (stop being modified for 20 seconds)
+    app.post('/wait-for-file-stable', async (req, res) => {
+        // Disable request timeout for long-running file monitoring
+        req.setTimeout(0);
+        const { file_path, min_size_mb = 1, max_wait_minutes = 120 } = req.body;
+        if (!file_path) {
+            return res.status(400).json({ error: 'file_path is required' });
+        }
+        const minSizeBytes = min_size_mb * 1024 * 1024; // Convert MB to bytes
+        const checkInterval = 5000; // Check every 5 seconds
+        const stableDuration = 20000; // 20 seconds of no changes
+        const maxWaitTime = max_wait_minutes * 60 * 1000; // Convert minutes to milliseconds
+        let lastModified = null;
+        let stableStart = null;
+        const startTime = Date.now();
+        console.log(`Starting to monitor file: ${file_path} (min size: ${min_size_mb}MB, max wait: ${max_wait_minutes}min)`, 'file-monitor-start');
+        const monitorFile = async () => {
+            try {
+                if (fs.existsSync(file_path)) {
+                    const stats = fs.statSync(file_path);
+                    const currentModified = stats.mtime.getTime();
+                    const currentSize = stats.size;
+                    // Check if file meets minimum size requirement
+                    if (currentSize < minSizeBytes) {
+                        // File too small, reset stability timer
+                        lastModified = currentModified;
+                        stableStart = null;
+                        console.log(`File ${file_path} too small (${(currentSize / 1024 / 1024).toFixed(2)}MB < ${min_size_mb}MB)`, 'file-monitor-small');
+                    }
+                    else if (lastModified === null || currentModified > lastModified) {
+                        // File was modified or first check
+                        lastModified = currentModified;
+                        stableStart = null;
+                        console.log(`File ${file_path} modified at ${new Date(currentModified).toISOString()} (${(currentSize / 1024 / 1024).toFixed(2)}MB)`, 'file-monitor-update');
+                    }
+                    else if (stableStart === null) {
+                        // File hasn't changed and meets size requirement, start counting stability
+                        stableStart = Date.now();
+                        console.log(`File ${file_path} stable start: ${new Date(stableStart).toISOString()} (${(currentSize / 1024 / 1024).toFixed(2)}MB)`, 'file-monitor-stable-start');
+                    }
+                    else if (Date.now() - stableStart >= stableDuration) {
+                        // File has been stable for required duration and meets size requirement
+                        console.log(`File ${file_path} stable for ${stableDuration / 1000}s (${(currentSize / 1024 / 1024).toFixed(2)}MB)`, 'file-monitor-complete');
+                        return res.json({
+                            file_path,
+                            stable: true,
+                            file_size: currentSize,
+                            file_size_mb: currentSize / (1024 * 1024),
+                            last_modified: new Date(currentModified).toISOString()
+                        });
+                    }
+                }
+                else {
+                    // File doesn't exist yet
+                    lastModified = null;
+                    stableStart = null;
+                }
+                // Check for timeout
+                if (Date.now() - startTime > maxWaitTime) {
+                    console.log(`Timeout waiting for file ${file_path} to stabilize`, 'file-monitor-timeout');
+                    return res.status(408).json({ error: 'Timeout waiting for file to stabilize' });
+                }
+                // Wait and check again
+                await new Promise(resolve => setTimeout(resolve, checkInterval));
+                await monitorFile();
+            }
+            catch (error) {
+                console.log(`Error monitoring file ${file_path}: ${error.message}`, 'file-monitor-error');
+                return res.status(500).json({ error: `Error monitoring file: ${error.message}` });
+            }
+        };
+        // Start monitoring
+        monitorFile();
+    });
+    // Get node context by node ID
+    app.get('/nodecontext/:nodeId', (req, res) => {
+        try {
+            const { nodeId } = req.params;
+            const valuesFile = path.join(process.cwd(), 'node_values.ndjson');
+            if (!fs.existsSync(valuesFile)) {
+                return res.status(404).json({ error: 'No node values file found' });
+            }
+            const lines = fs.readFileSync(valuesFile, 'utf8').trim().split('\n');
+            // Find the entry for this nodeId
+            for (const line of lines) {
+                try {
+                    const entry = JSON.parse(line);
+                    if (entry.nodeId === nodeId) {
+                        return res.json({
+                            nodeId: entry.nodeId,
+                            value: entry.value,
+                            input: entry.input,
+                            timestamp: entry.timestamp
+                        });
+                    }
+                }
+                catch (e) {
+                    // Skip malformed lines
+                    continue;
+                }
+            }
+            return res.status(404).json({ error: `No value found for node ${nodeId}` });
+        }
+        catch (err) {
+            console.error('Error retrieving node context:', err);
+            res.status(500).json({ error: 'Internal server error' });
+        }
+    });
+    // Clear node values file
+    app.post('/clear-node-values', async (req, res) => {
+        try {
+            const valuesFile = path.join(process.cwd(), 'node_values.ndjson');
+            // Clear the file by writing an empty string
+            fs.writeFileSync(valuesFile, '', 'utf8');
+            console.log('Node values file cleared successfully', 'clear-node-values');
+            res.json({ success: true, message: 'Node values file cleared successfully' });
+        }
+        catch (err) {
+            console.error('Error clearing node values file:', err);
+            res.status(500).json({ error: 'Failed to clear node values file' });
+        }
+    });
+    // Get settings file contents
+    app.get('/get-settings', (req, res) => {
+        try {
+            const settingsFilePath = get(KEYS.SETTINGS_FILE);
+            if (!settingsFilePath) {
+                console.log('No SETTINGS_FILE path configured', 'get-settings');
+                return res.json({});
+            }
+            if (!fs.existsSync(settingsFilePath)) {
+                console.log(`Settings file does not exist: ${settingsFilePath}`, 'get-settings');
+                return res.json({});
+            }
+            const settingsContent = fs.readFileSync(settingsFilePath, 'utf8');
+            const settings = JSON.parse(settingsContent);
+            console.log(`Successfully loaded settings from: ${settingsFilePath}`, 'get-settings');
+            res.json(settings);
+        }
+        catch (error) {
+            console.error('Error reading settings file:', error);
+            res.status(500).json({ error: `Failed to read settings file: ${error.message}` });
+        }
+    });
+    app.post('/buildWorkflowDirectory', async (req, res) => {
+        const { jsonInput, targetDir } = req.body;
+        if (!jsonInput || !targetDir) {
+            return res.status(400).json({ error: 'Missing jsonInput or targetDir' });
+        }
+        try {
+            const result = await buildWorkflowDirectory(jsonInput, targetDir);
+            res.json(result);
+        }
+        catch (error) {
+            console.error('Error in /buildWorkflowDirectory:', error);
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.post('/runWorkflowCLI', async (req, res) => {
+        const { targetDir, workflowJsonPath, parameters } = req.body;
+        if (!targetDir) {
+            return res.status(400).json({ error: 'Missing targetDir or workflowJsonPath' });
+        }
+        try {
+            const result = await runWorkflowCLI(targetDir, workflowJsonPath, parameters);
+            res.json(result);
+        }
+        catch (error) {
+            console.error('Error in /runWorkflowCLI:', error);
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.post('/installDependencies', async (req, res) => {
+        const { targetDir } = req.body;
+        if (!targetDir) {
+            return res.status(400).json({ error: 'Missing targetDir' });
+        }
+        try {
+            const result = await installDependencies(targetDir);
+            res.json(result);
+        }
+        catch (error) {
+            console.error('Error in /installDependencies:', error);
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.get('/get-extensions', async (req, res) => {
+        const folders = get(KEYS.extension_folders);
+        const extensions = await scanExtensions(folders);
+        res.json({ extensions });
+    });
+    app.post('/generate-ui-map', async (req, res) => {
+        try {
+            const { files } = req.body;
+            if (!files) {
+                return res.status(400).json({ error: 'Files are required' });
+            }
+            console.log(`[running] generate-ui-map for ${files}`, 'generate-ui-map');
+            let workflow_folder = (get(KEYS.workflow_folder));
+            // if the files are relative paths, make them absolute based on workflow_folder
+            const absoluteFiles = files.map(file => {
+                if (!path.isAbsolute(file)) {
+                    return path.join(workflow_folder, file);
+                }
+                return file;
+            });
+            console.log(absoluteFiles);
+            const uiMap = await generateUIMap(absoluteFiles);
+            console.log(`[done] generate-ui-map for ${files}`, 'generate-ui-map');
+            res.json({
+                success: true,
+                files,
+                uiMap
+            });
+        }
+        catch (error) {
+            console.log(`Error in generate-ui-map: ${error.message}`, 'generate-ui-map-error');
+            res.status(500).json({ error: `Failed to generate UI map: ${error.message}` });
+        }
+    });
+}
+//# sourceMappingURL=standardRoutes.js.map