flow-frame-core 0.1.0

package/dist/operations.js

@@ -0,0 +1,1514 @@
+import robot from 'robotjs';
+import { KEYS } from './constants.js';
+import { setItem, getItem } from './storage.js';
+import os from 'os';
+import fs from 'fs';
+import { fix } from './process.js';
+import path from 'path';
+import { getFiles, findVideoJobs, sanitizeFileName, getDetectOrientation, readProjectFile, saveProjectFile, countFilesInDownloads, findSocialPorterVideos, moveSocialPorterVideos, console_log_it, findFileInDirectoryHasInWithAndEndingWith, pasteText, waitFor, isThere, pressReturn, pause, waitForQueuedRenders, ifYouDontFinish, refreshScreen, extractVersionNumber, getContext, MIDJOURNEY_SELECTOR, findFilesWithString, get, set, getModePositionKey, buildProgressBar, get_jobs_path, processSunoState, getFilesToProcess, workflowOp } from './utils.js';
+// Import missing constants/functions
+import { MODES, SUNO_SELECTORS, YOUTUBE_SELECTORS } from './constants.js';
+import { safeExtractJSON } from './jsonHandler.js';
+const WAIT_FACTOR = 0.25;
+const chrome_offsets = { x: 1, y: 125 };
+export async function moveMouse(position) {
+    const { left, top, height, width } = position;
+    // {
+    //     height: 23.99147605895996,
+    //     left: 419.8692932128906,
+    //     top: 379.8948860168457,
+    //     width: 1170.241455078125
+    //   }
+    // Define the target coordinates (x, y)
+    const targetX = left + chrome_offsets.x + (width / 2);
+    const targetY = top + chrome_offsets.y + (height / 4);
+    console_log_it(`Moving mouse to (${targetX}, ${targetY})...`);
+    // Move the mouse smoothly to the target coordinates
+    if (isWindows()) {
+        robot.moveMouse(targetX, targetY);
+    }
+    else
+        robot.moveMouseSmooth(targetX, targetY);
+}
+export async function mouseClick() {
+    await pause(() => {
+        robot.mouseClick(); // Performs a left-click.
+    }, 1000); // 1 second delay for safety
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+export async function pressEscapeAsync() {
+    robot.keyToggle("escape", "down"); // press down
+    await sleep(500); // wait 0.5 seconds
+    robot.keyToggle("escape", "up"); // release
+}
+export async function moveMouseDesktop(position) {
+    const { left, top, height, width } = position;
+    // {
+    //     height: 23.99147605895996,
+    //     left: 419.8692932128906,
+    //     top: 379.8948860168457,
+    //     width: 1170.241455078125
+    //   }
+    // Define the target coordinates (x, y)
+    const targetX = left + (width / 2);
+    const targetY = top + (height / 2);
+    console_log_it(`Moving mouse to (${targetX}, ${targetY})...`, '[moveMouseDesktop]');
+    // Move the mouse smoothly to the target coordinates
+    if (isWindows()) {
+        robot.moveMouse(targetX, targetY);
+    }
+    else
+        robot.moveMouseSmooth(targetX, targetY);
+}
+export async function moveMouseRelative(relative) {
+    let mousePos = robot.getMousePos();
+    const { left, top } = relative;
+    console_log_it(`Moving mouse to relative position (${left}, ${top})...`, '[moveMouseRelativerelativeposition]');
+    console_log_it(`Current mouse position: (${JSON.stringify(mousePos, null, 3)})`, '[moveMousePositionRelative]');
+    // {
+    //     height: 23.99147605895996,
+    //     left: 419.8692932128906,
+    //     top: 379.8948860168457,
+    //     width: 1170.241455078125
+    //   }
+    // Define the target coordinates (x, y)
+    const targetX = left + (mousePos.x);
+    const targetY = top + (mousePos.y);
+    console_log_it(`Moving mouse to (${targetX}, ${targetY})...`, '[moveMouseRelative]');
+    // Move the mouse smoothly to the target coordinates
+    robot.moveMouseSmooth(targetX, targetY);
+}
+/**
+ * Returns true if the current platform is Windows.
+ * @returns {boolean}
+ */
+export function isWindows() {
+    // os.platform() yields 'win32' on Windows (both 32‑bit and 64‑bit)
+    return os.platform() === 'win32';
+}
+function pressEscape() {
+    // Tap "escape" (down + up)
+    robot.keyTap('escape');
+}
+/**
+ * Presses (taps) the Down Arrow key once.
+ */
+function pressDownArrow() {
+    robot.keyTap('down');
+}
+export async function operateMidjourneyDownloadPublicMedia() {
+    pressEscape();
+    const SPEED = parseInt(get(KEYS.speed) || '5000') || 5000;
+    console_log_it('[operateMidjourneyDownloadPublicMedia]', 'func');
+    let filesDownloaded = 0;
+    try {
+        console_log_it('[operateMidjourneyDownloadPublicMedia] waiting for video button', 'func');
+        await waitFor(async () => {
+            return getModePositionKey(MIDJOURNEY_SELECTOR.videoButton);
+        });
+        console_log_it('[operateMidjourneyDownloadPublicMedia] moving to video button', 'func');
+        await moveMouse(getModePositionKey(MIDJOURNEY_SELECTOR.videoButton));
+        await pause(() => {
+            console_log_it("Performing left click...", 'func');
+            robot.mouseClick(); // Performs a left-click.
+        }, 1000); // 1 second delay for safety}
+        try {
+            await pause(() => {
+                console_log_it("Waiting for download button to appear...", 'func');
+            }, SPEED * 2);
+            // Wait for the download button to appear
+            while (true) {
+                await findSocialPorterVideos()
+                    .then(files => moveSocialPorterVideos(files, path.join(get(KEYS.images_folder), 'top_ten_videos')))
+                    .catch(console.error);
+                try {
+                    await waitFor(async () => {
+                        return getModePositionKey(MIDJOURNEY_SELECTOR.useText);
+                    }, 2 * 1000);
+                    await moveMouse(getModePositionKey(MIDJOURNEY_SELECTOR.useText));
+                    await pause(() => {
+                        console_log_it("Performing left click...", 'func');
+                        robot.mouseClick(); // Performs a left-click.
+                    }, 1000); // 1 second delay for safety}
+                    await pause(() => {
+                        console_log_it("Performing left click...", 'func');
+                        robot.mouseClick(); // Performs a left-click.
+                    }, 1000); // 1 second delay for safety}
+                    await waitFor(async () => {
+                        return getModePositionKey(MIDJOURNEY_SELECTOR.lightboxPrompt);
+                    }, 10 * 1000);
+                    let { innerText } = getModePositionKey(MIDJOURNEY_SELECTOR.lightboxPrompt);
+                    let jobs = findVideoJobs(innerText);
+                    console_log_it(`jobs : ${jobs?.length}..."`, 'jobs');
+                    let all_jobs_done = jobs.every(job => {
+                        for (let i = 0; i < job.batch_size; i++) {
+                            if (!findFileInDirectoryHasInWithAndEndingWith(path.join(get(KEYS.images_folder), 'top_ten_videos'), `${job.id}_${i}`, '.mp4')) {
+                                return false;
+                            }
+                        }
+                        return true;
+                    });
+                    console_log_it(`${all_jobs_done}..."`, 'all_jobs_done');
+                    if (jobs?.length && all_jobs_done) {
+                        pressDownArrow();
+                        await pause(() => {
+                            console_log_it("Performing left click...", 'func');
+                        }, 1000); // 1 second delay for safety
+                        continue;
+                    }
+                }
+                catch (e) {
+                    console_log_it("No prompt found, continuing...", 'error');
+                    console_log_it(e, 'e');
+                    pressDownArrow();
+                    continue;
+                }
+                try {
+                    await waitFor(async () => {
+                        return getModePositionKey(MIDJOURNEY_SELECTOR.optionsButton);
+                    });
+                    await moveMouse(getModePositionKey(MIDJOURNEY_SELECTOR.optionsButton));
+                    await pause(() => {
+                        robot.mouseClick(); // Performs a left-click.
+                    }, 1000);
+                    await waitFor(async () => {
+                        return getModePositionKey(MIDJOURNEY_SELECTOR.optionsDownloadButton);
+                    });
+                    await moveMouse(getModePositionKey(MIDJOURNEY_SELECTOR.optionsDownloadButton));
+                    await pause(() => {
+                        robot.mouseClick(); // Performs a left-click.
+                    }, 1000);
+                }
+                catch (e) {
+                    pressDownArrow();
+                    await pause(() => {
+                        console_log_it("Performing left click...", 'func');
+                    }, 1000); // 1 second delay for safety}
+                    continue;
+                }
+                let filesInDownloads = countFilesInDownloads();
+                try {
+                    await waitFor(async () => {
+                        let currentCount = countFilesInDownloads();
+                        return filesInDownloads !== currentCount;
+                    });
+                }
+                catch (e) {
+                    console_log_it("No new files in downloads, continuing...", 'error');
+                }
+                await pause(() => {
+                    console_log_it("Performing left click...", 'func');
+                }, SPEED); // 1 second delay for safety}
+                pressDownArrow();
+                console_log_it(`Files downloaded: ${filesDownloaded}`, 'files_downloaded');
+                console_log_it(buildProgressBar(filesDownloaded, 10), 'progress_bar');
+                filesDownloaded++;
+                if (filesDownloaded >= 12) {
+                    console_log_it('Reached 12 files downloaded, stopping...', 'files_downloaded');
+                    break;
+                }
+            }
+        }
+        catch (e) {
+            console_log_it(e, 'error');
+            console_log_it('Error in operateMidjourneyDownloadPublicMedia', 'func');
+        }
+    }
+    catch (e) {
+        console_log_it(e, 'error');
+        console_log_it('Error in operateMidjourneyDownloadPublicMedia', 'func');
+        throw e;
+    }
+    console_log_it('[done operateMidjourneyDownloadPublicMedia]', 'func');
+}
+export async function operateMidjourneyDownloadMedia() {
+    pressEscape();
+    const SPEED = parseInt(get(KEYS.speed) || '5000') || 5000;
+    console_log_it('[operateMidjourneyDownloadMedia]', 'func');
+    await waitFor(async () => {
+        return getModePositionKey(MIDJOURNEY_SELECTOR.firstImageCell);
+    });
+    await moveMouse(getModePositionKey(MIDJOURNEY_SELECTOR.firstImageCell));
+    await pause(() => {
+        console_log_it("Performing left click...");
+        robot.mouseClick(); // Performs a left-click.
+    }, 1000); // 1 second delay for safety}
+    try {
+        await pause(() => {
+            console_log_it("Waiting for download button to appear...");
+        }, SPEED * 2);
+        // Wait for the download button to appear
+        while (true) {
+            await findSocialPorterVideos()
+                .then(files => moveSocialPorterVideos(files, get(KEYS.images_folder)))
+                .catch(console.error);
+            await waitFor(async () => {
+                return getModePositionKey(MIDJOURNEY_SELECTOR.lightboxPrompt);
+            });
+            try {
+                let { innerText } = getModePositionKey(MIDJOURNEY_SELECTOR.lightboxPrompt);
+                let jobs = findVideoJobs(innerText);
+                console_log_it(`jobs : ${jobs?.length}..."`, 'jobs');
+                let all_jobs_done = jobs.every(job => {
+                    for (let i = 0; i < job.batch_size; i++) {
+                        if (!findFileInDirectoryHasInWithAndEndingWith(get(KEYS.images_folder), `${job.id}_${i}`, '.mp4')) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+                console_log_it(`${all_jobs_done}..."`, 'all_jobs_done');
+                if (jobs?.length && all_jobs_done) {
+                    pressDownArrow();
+                    await pause(() => {
+                        console_log_it("Performing left click...");
+                    }, 1000); // 1 second delay for safety
+                    continue;
+                }
+            }
+            catch (e) {
+                console_log_it("No prompt found, continuing...", 'error');
+                console_log_it(e, 'e');
+                throw e;
+            }
+            try {
+                await waitFor(async () => {
+                    return getModePositionKey(MIDJOURNEY_SELECTOR.downloadButton);
+                });
+                await moveMouse(getModePositionKey(MIDJOURNEY_SELECTOR.downloadButton));
+            }
+            catch (e) {
+                pressDownArrow();
+                await pause(() => {
+                    console_log_it("Performing left click...");
+                }, 1000); // 1 second delay for safety}
+                continue;
+            }
+            let filesIndDownloads = countFilesInDownloads();
+            await pause(() => {
+                console_log_it("Performing left click...");
+                robot.mouseClick(); // Performs a left-click.
+            }, 1000); // 1 second delay for safety}
+            await waitFor(async () => {
+                return getModePositionKey(MIDJOURNEY_SELECTOR.ilikeRadiobutton) && getModePositionKey(MIDJOURNEY_SELECTOR.iNeutralRadiobutton);
+            });
+            try {
+                await waitFor(async () => {
+                    let currentCount = countFilesInDownloads();
+                    return filesIndDownloads !== currentCount;
+                });
+            }
+            catch (e) {
+                console_log_it("No new files in downloads, continuing...", 'error');
+            }
+            if (Math.random() < 0.5) {
+                await moveMouse(getModePositionKey(MIDJOURNEY_SELECTOR.ilikeRadiobutton));
+                await pause(() => {
+                    console_log_it("Performing left click on 'I like' radio button...");
+                    robot.mouseClick(); // Performs a left-click.
+                }, 1000); // 1 second delay for safety}
+            }
+            else {
+                await moveMouse(getModePositionKey(MIDJOURNEY_SELECTOR.iNeutralRadiobutton));
+                await pause(() => {
+                    console_log_it("Performing left click on 'Neutral' radio button...");
+                    robot.mouseClick(); // Performs a left-click.
+                }, 1000); // 1 second delay for safety}
+            }
+            await pause(() => {
+                console_log_it("Performing left click...");
+            }, SPEED); // 1 second delay for safety}
+            pressDownArrow();
+        }
+    }
+    catch (e) {
+        console_log_it(e, 'error');
+        console_log_it('Error in operateMidjourneyDownloadMedia');
+    }
+    console_log_it('[done operateMidjourneyDownloadMedia]', 'func');
+}
+export async function operateMidjourneyToImages() {
+    const SPEED = parseInt(get(KEYS.speed) || '5000') || 5000;
+    let skipped = 0;
+    let lastTime = get(KEYS.LastMidjourneyToImages);
+    if (!lastTime) {
+        set(KEYS.LastMidjourneyToImages, {
+            project: 'The Tall Tree / L’Arbre',
+            prompt: 8,
+            animate: 0
+        });
+    }
+    let failed = false;
+    console_log_it('[operateMidjourneyToImages]', 'func');
+    try {
+        const root_folder = get(KEYS.current_folder);
+        const name = getItem('sourceFile');
+        let skipping = 0;
+        let filesToProcess = [name];
+        console_log_it('[operateMidjourneyToImages getFileToProcess]', 'func');
+        filesToProcess = getFilesToProcess(name, filesToProcess, root_folder);
+        let e1 = [];
+        console_log_it(`[operateMidjourneyToImages ${filesToProcess}]`, 'func');
+        filesToProcess.filter(x => x.endsWith('.json')).forEach((fileP) => {
+            console_log_it(fileP, 'file to operate');
+            let projects = readProjectFile(path.join(root_folder, fileP));
+            let sub_lyric_projects = projects.map(t => {
+                return t.lyrics || [];
+            }).flat();
+            e1 = [...e1, ...sub_lyric_projects, ...(sub_lyric_projects?.length ? projects : [])];
+        });
+        let foundFirst = false;
+        let skipFirstPrompts = false;
+        let skipFirstAnimates = false;
+        const SIMULTANEOUS_JOBS = parseInt(get(KEYS.simultaneous_jobs) || '1') || 1;
+        let simultaneousJobs = SIMULTANEOUS_JOBS;
+        for (let i = 0; i < e1.length; i++) {
+            let section = e1[i];
+            console_log_it(buildProgressBar(i + 1, e1.length, 20), 'overall-progress');
+            const { name, portrait_prompt, prompts, characters, prompts_selection, animated_images = {} } = section;
+            // if (lastTime.project) {
+            //     if (lastTime.project !== name && !foundFirst) {
+            //         continue;
+            //     }
+            //     else if (lastTime.project === name && !foundFirst) {
+            //         foundFirst = true;
+            //         skipFirstPrompts = true;
+            //     }
+            // }
+            for (let j = 0; j < prompts.length; j++) {
+                let prompt = prompts[j];
+                console_log_it(buildProgressBar(j + 1, prompts.length, 20), 'prompts-progress');
+                let jobs = findVideoJobs(prompt);
+                if (jobs.length) {
+                    console_log_it('Skipping ' + skipped, 'already_done');
+                    skipped++;
+                    continue;
+                }
+                if (skipFirstPrompts) {
+                    j = Math.min(prompts.length - 1, lastTime.prompt);
+                    skipFirstPrompts = false;
+                    skipFirstAnimates = true;
+                }
+                if (prompt && prompts_selection[prompt]) {
+                    let imagesToAnimate = prompts_selection[prompt] || [];
+                    let k_start = 0;
+                    if (skipFirstAnimates) {
+                        k_start = lastTime.animate || 0;
+                        skipFirstAnimates = false;
+                    }
+                    let cancelIt = ifYouDontFinish(() => {
+                        refreshScreen(robot);
+                    }, 10 * 60 * 1000);
+                    for (let k = k_start; k < imagesToAnimate.length; k++) {
+                        console_log_it(buildProgressBar(k, imagesToAnimate.length, 20), 'animate-progress');
+                        let imageToAnimate = imagesToAnimate[k];
+                        if (!animated_images?.[imageToAnimate]) {
+                            await clearMidjourneyImages();
+                            await animateImageWithMidjourney(imageToAnimate, prompt);
+                            section.animated_images = {
+                                ...section.animated_images,
+                                [imageToAnimate]: true
+                            };
+                            set(KEYS.LastMidjourneyToImages, {
+                                project: name,
+                                prompt: j,
+                                animate: k
+                            });
+                            await pause(() => { }, SPEED); // wait a second to ensure 
+                            simultaneousJobs--;
+                            if (simultaneousJobs <= 0) {
+                                console_log_it('Waiting for rendering to finish...', 'state');
+                                simultaneousJobs = SIMULTANEOUS_JOBS;
+                                await waitForRendering(SPEED);
+                            }
+                            //save the project again.
+                        }
+                    }
+                    cancelIt();
+                }
+            }
+        }
+    }
+    catch (e) {
+        console_log_it(e, 'error');
+        failed = true;
+    }
+    if (!failed) {
+        set(KEYS.LastMidjourneyToImages, {
+            project: '',
+            prompt: 0,
+            animate: 0
+        });
+    }
+    console_log_it('[done operateMidjourneyToImages]', 'func');
+}
+/**
+ * Parse an image filename of the form:
+ *   <username>_<prompt>_i_<guid>_<imageNumber>.png
+ *
+ * @param {string} filename
+ * @returns {{
+ *   username: string,
+ *   prompt: string,
+ *   guid: string,
+ *   image_number: number
+ * }}
+ */
+function parseImageName(filename) {
+    // Adjust the extension if you support other formats (jpg, webp, etc.)
+    const re = /^([^_]+)_(.+)_i_([0-9a-fA-F-]{36})_(\d+)\.png$/;
+    const match = filename.match(re);
+    if (!match) {
+        throw new Error(`Filename "${filename}" does not match expected pattern.`);
+    }
+    const [, // full match
+    username, // group 1
+    prompt, // group 2
+    guid, // group 3
+    imageNumStr // group 4
+    ] = match;
+    return {
+        username,
+        prompt,
+        guid,
+        image_number: parseInt(imageNumStr, 10)
+    };
+}
+async function animateImageWithMidjourney(imageFileName, prompt) {
+    const SPEED = parseInt(get(KEYS.speed) || '5000') || 5000;
+    await openMidjourneyImagePanel();
+    await waitFor(async () => {
+        return getModePositionKey(MIDJOURNEY_SELECTOR.chooseAnImage);
+    });
+    await moveMouse(getModePositionKey(MIDJOURNEY_SELECTOR.chooseAnImage));
+    await pause(() => {
+        console_log_it("Uploading image", 'state');
+        robot.mouseClick(); // Performs a left-click.
+    }, 1000); // 1 second delay for safety} 
+    await fileModalOperate(path.join(get(KEYS.images_folder), imageFileName));
+    await waitFor(async () => {
+        return getModePositionKey(MIDJOURNEY_SELECTOR.promptImage);
+    });
+    await pause(() => { }, SPEED);
+    let animateButton = getCenteredRectAtOffset(getModePositionKey(MIDJOURNEY_SELECTOR.promptImage), 20, -20, 20, 20, true);
+    await moveMouse(animateButton);
+    await pause(() => {
+        console_log_it("Deleting image", 'state');
+        robot.mouseClick(); // Performs a left-click.
+    }, 1000); // 1 second delay for safety} 
+    pressEscape();
+    await pause(() => { }, 3400);
+    await moveMouse(getModePositionKey(MIDJOURNEY_SELECTOR['[id="desktop_input_bar"]']));
+    await pause(() => {
+        console_log_it("starting", 'state');
+        robot.mouseClick(); // Performs a left-click.
+    }, 1000); // 1 second delay for safety} 
+    if (typeof prompt === 'string') {
+        await pasteText(prompt);
+        await pause(() => { }, SPEED);
+        robot.keyTap('enter');
+        await pause(() => { }, SPEED);
+    }
+}
+export async function typeText(params) {
+    const { keys, ctrl = false, shift = false, alt = false } = params;
+    // Build modifier array
+    const modifiers = [];
+    if (ctrl) {
+        modifiers.push(isWindows() ? 'ctrl' : 'command');
+    }
+    if (shift) {
+        modifiers.push('shift');
+    }
+    if (alt) {
+        modifiers.push(isWindows() ? 'alt' : 'option');
+    }
+    const modifierString = modifiers.length > 0 ? modifiers.join('+') + '+' : '';
+    console_log_it(`Typing keys: ${modifierString}${keys}`, '[typeText]');
+    // Use robotjs keyTap with modifier array (not string)
+    robot.keyTap(keys, modifiers);
+}
+export async function pressKey(params) {
+    const { keys, ctrl = false, shift = false, alt = false } = params;
+    // Build modifier array
+    const modifiers = [];
+    if (ctrl) {
+        robot.keyToggle(isWindows() ? 'ctrl' : 'command', 'down'); // Ensure control is pressed down
+    }
+    await pause(() => { }, 100); // Short pause to ensure control is pressed
+    // Use robotjs keyTap with modifier array (not string)
+    robot.keyTap(keys);
+    await pause(() => { }, 100); // Short pause to ensure control is pressed
+    if (ctrl) {
+        robot.keyToggle(isWindows() ? 'ctrl' : 'command', 'up'); // Ensure control is released
+    }
+}
+async function waitForRendering(SPEED) {
+    let stillRendering = false;
+    do {
+        await pause(() => { }, SPEED * 2);
+        stillRendering = await isThere(() => {
+            return getModePositionKey(MIDJOURNEY_SELECTOR.starting) ||
+                getModePositionKey(MIDJOURNEY_SELECTOR.completing) ||
+                getModePositionKey(MIDJOURNEY_SELECTOR.queued);
+        });
+        await moveMouse(getModePositionKey(MIDJOURNEY_SELECTOR['[id="desktop_input_bar"]']));
+        await moveMouse(getModePositionKey(MIDJOURNEY_SELECTOR.addImageBtn));
+        console_log_it(getModePositionKey(MIDJOURNEY_SELECTOR.starting), 'starting-position');
+        console_log_it(getModePositionKey(MIDJOURNEY_SELECTOR.completing), 'completing-position');
+        if (stillRendering) {
+            console_log_it(`stilling rendering ${new Date(Date.now()).toISOString()}`, 'state');
+        }
+        else {
+            console_log_it(`done rendering ${new Date(Date.now()).toISOString()}`, 'state');
+        }
+    } while (stillRendering);
+}
+export async function openMidjourneyImagePanel() {
+    pressEscape();
+    console_log_it('clear midjourney images', 'operation');
+    await waitFor(async () => {
+        console_log_it(getModePositionKey(MIDJOURNEY_SELECTOR.addImageBtn));
+        return getModePositionKey(MIDJOURNEY_SELECTOR.addImageBtn);
+    });
+    await moveMouse(getModePositionKey(MIDJOURNEY_SELECTOR.addImageBtn));
+    await pause(() => {
+        console_log_it("Performing left click...");
+        robot.mouseClick(); // Performs a left-click.
+    }, 1000); // 1 second delay for safety
+}
+export async function clearMidjourneyImages(all = true) {
+    try {
+        const SPEED = parseInt(get(KEYS.speed) || '5000') || 5000;
+        while (all) {
+            await openMidjourneyImagePanel();
+            await pause(() => { }, SPEED);
+            let deletButton = getCenteredRectAtOffset(getModePositionKey(MIDJOURNEY_SELECTOR.promptImage), -20, -20, 20, 20);
+            await moveMouse(deletButton);
+            await pause(() => {
+                console_log_it("Deleting image", 'state');
+                robot.mouseClick(); // Performs a left-click.
+            }, 1000); // 1 second delay for safety} 
+            await pause(() => { }, 3400);
+        }
+    }
+    catch (e) {
+        console_log_it('done deleting images', 'state');
+        pressEscape();
+    }
+}
+/**
+ * Returns a rectangle of a given size, centered at an offset from the
+ * source rectangle. By default it's offset from the bottom-right.
+ * If `left` is true, it's offset from the bottom-left instead.
+ *
+ * @param {Object} rect           – the source rectangle, with numeric top, left, width, height
+ * @param {number} offsetX        – horizontal offset (default: 10)
+ * @param {number} offsetY        – vertical offset (default: 10)
+ * @param {number} [outWidth]     – output rectangle width (default: rect.width)
+ * @param {number} [outHeight]    – output rectangle height (default: rect.height)
+ * @param {boolean} [left=false]  – if true, offset from the left side of the source
+ * @returns {Object} a new rect { top, left, width, height }
+ */
+function getCenteredRectAtOffset(rect, offsetX = 10, offsetY = 10, outWidth = rect.width, outHeight = rect.height, left = false) {
+    // Choose the starting X point
+    const baseX = left ? rect.left : (rect.left + rect.width);
+    const centerX = baseX + offsetX;
+    // Always offset from the bottom
+    const centerY = rect.top + rect.height + offsetY;
+    // Create a new rect centered at (centerX, centerY)
+    return {
+        top: centerY - outHeight / 2,
+        left: centerX - outWidth / 2,
+        width: outWidth,
+        height: outHeight,
+    };
+}
+export async function operateYoutubeMouse() {
+    console_log_it('[YOUTUBE]', 'mode-filter');
+    let attempts = 10;
+    let success = false;
+    while (attempts > 0 && !success) {
+        try {
+            const SPEED = parseInt(get(KEYS.speed) || '5000') || 5000;
+            console.clear();
+            console_log_it('operate youtube', '[YOUTUBE] func');
+            console_log_it(`Operating Youtube with mode: ${get(KEYS.mode)}`, '[YOUTUBE] running-mode');
+            let currentSourceFilePath = path.join(get(KEYS.current_folder), get(KEYS.sourceFile));
+            let overAllCurrentSources = readProjectFile(currentSourceFilePath);
+            let dateOffset = 1;
+            try {
+                dateOffset = parseFloat(get(KEYS.days_offset)) || 1;
+            }
+            catch (e) {
+                console_log_it('bad date offset', '[YOUTUBE] bad date offset');
+                dateOffset = 1;
+            }
+            let currentSources = [];
+            overAllCurrentSources.forEach((source) => {
+                currentSources.push(source);
+                if (source?.lyrics?.length && source?.lyrics?.length > 0) {
+                    source.lyrics.forEach((lyric) => { currentSources.push(lyric); });
+                }
+            });
+            let firstIndex = 0;
+            let firstVideo = get(KEYS.firstVideoForUpload);
+            firstIndex = currentSources.findIndex(d => firstVideo && d.name === firstVideo);
+            if (firstIndex === -1) {
+                firstIndex = 0;
+            }
+            console_log_it(`Progress: ${currentSources.length}`, '[YOUTUBE] youtube-progress');
+            const PER_DAY = parseInt(get(KEYS.publishPerDay) || '1') || 1;
+            let count = 0;
+            for (let i = firstIndex; i < currentSources.length; i++) {
+                console_log_it(`Current Sources: ${buildProgressBar(i, currentSources.length, 20)}`, '[YOUTUBE] youtube-progress');
+                let { name, title, original_name = '', youtubeDescription = null, description = '', uploaded = false, forKids } = currentSources[i];
+                if (uploaded) {
+                    continue;
+                }
+                if (!name) {
+                    name = title || original_name;
+                }
+                if (!name) {
+                    console_log_it(`Skipping source with no name:`, '[YOUTUBE] youtube-progress');
+                    continue;
+                }
+                let youtubeData = safeExtractJSON(youtubeDescription, {
+                    returnOriginalOnFail: false,
+                    defaultValue: null,
+                });
+                description = description.substring(0, 2000);
+                console_log_it(`${JSON.stringify(youtubeData)}`, '[YOUTUBE] youtubeData');
+                console_log_it(`${JSON.stringify(youtubeDescription)}`, '[YOUTUBE] youtubeDescription');
+                if (youtubeData && youtubeData.description) {
+                    description = youtubeData.description.substring(0, 2000);
+                }
+                else if (typeof youtubeDescription === 'string') {
+                    description = youtubeDescription.substring(0, 2000);
+                }
+                let prefix_name = fix(name);
+                prefix_name = sanitizeFileName(prefix_name);
+                if (prefix_name?.length >= 3) {
+                    let filesForUpload = findFilesWithString(get(KEYS.renders_folder), prefix_name);
+                    console_log_it(`prefix_name: ${prefix_name}`, '[YOUTUBE] prefix_name');
+                    console_log_it(`currentSource: `, '[YOUTUBE] currentSource');
+                    for (let j = 0; j < filesForUpload.length; j++) {
+                        let fileForUpload = filesForUpload[j];
+                        console_log_it(`filesForUpload: ${buildProgressBar(fileForUpload, filesForUpload.length, 20)}`, '[YOUTUBE] filesForUpload');
+                        {
+                            console_log_it(getContext().position?.[MODES.YOUTUBE], '[YOUTUBE] position');
+                            console_log_it(getContext().position?.[MODES.YOUTUBE]?.location, '[YOUTUBE] position-location');
+                            await waitFor(async () => {
+                                console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.createtn], '[YOUTUBE] currentelement');
+                                return getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.createtn];
+                            });
+                            console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.createtn], '[YOUTUBE] currentelement');
+                            await moveMouse(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.createtn]);
+                            await pause(async () => {
+                                console_log_it("Performing left click...", '[YOUTUBE] state');
+                                await mouseClick(); // Performs a left-click.
+                            }, 1000); // 1 second delay for safety
+                        }
+                        {
+                            await pause(() => { }, SPEED); // 1 second delay for safety
+                            await waitFor(async () => {
+                                console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.uploadVideo], '[YOUTUBE] currentelement');
+                                return getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.uploadVideo];
+                            });
+                            console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.uploadVideo], '[YOUTUBE] currentelement');
+                            await moveMouse(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.uploadVideo]);
+                            await pause(async () => {
+                                console_log_it("Performing left click...", '[YOUTUBE] state');
+                                await mouseClick(); // Performs a left-click.
+                            }, 1000); // 1 second delay for safety
+                        }
+                        {
+                            await pause(() => { console_log_it('wait 10s', '[YOUTUBE] '); }, SPEED); // 1 second delay for safety
+                            await waitFor(async () => {
+                                console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.selectFilesButton], '[YOUTUBE] currentelement');
+                                return getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.selectFilesButton];
+                            });
+                            console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.selectFilesButton], '[YOUTUBE] currentelement');
+                            await moveMouse(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.selectFilesButton]);
+                            await pause(async () => {
+                                console_log_it("Performing left click...", '[YOUTUBE] state');
+                                await mouseClick(); // Performs a left-click.
+                            }, 1000); // 1 second delay for safety
+                            await fileModalOperate(path.join(get(KEYS.renders_folder), fileForUpload));
+                        }
+                        {
+                            await pause(() => { console_log_it('wait 10s', '[YOUTUBE] '); }, SPEED); // 1 second delay for safety
+                            await waitFor(async () => {
+                                console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.titleInput], '[YOUTUBE] currentelement');
+                                return getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.titleInput];
+                            });
+                            await moveMouse(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.titleInput]);
+                            console_log_it(`original_name: ${original_name || name}`, '[YOUTUBE] ');
+                            await pause(async () => {
+                                console_log_it("Performing left click...", '[YOUTUBE] state');
+                                await mouseClick(); // Performs a left-click.
+                            }, 1000); // 1 second delay for safety
+                            clearAllText();
+                            await pasteText(`${original_name || name}`.substring(0, 100)); // YouTube title limit is 100 characters
+                            console_log_it(`pasted title: ${original_name || name}`, '[YOUTUBE] ');
+                        }
+                        {
+                            await pause(() => { console_log_it('wait 10s', '[YOUTUBE] '); }, SPEED); // 1 second delay for safety
+                            await waitFor(async () => {
+                                console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.descriptionInput], '[YOUTUBE] currentelement');
+                                return getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.descriptionInput];
+                            });
+                            await moveMouse(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.descriptionInput]);
+                            await pause(async () => {
+                                console_log_it("Performing left click...", '[YOUTUBE] state');
+                                await mouseClick(); // Performs a left-click.
+                            }, 1000); // 1 second delay for safety
+                            clearAllText();
+                            await pasteText(`${description || name}`.slice(0, 4999));
+                        }
+                        await pause(() => { }, SPEED);
+                        let point = { ...getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.descriptionInput] };
+                        point.left = point.left + point.width / 2 + 10;
+                        scroll(0, -1000); // Scroll down to make sure the styles are visible
+                        await moveMouse(point);
+                        scroll(0, -1000);
+                        {
+                            scroll(0, -1000); // Scroll down to make sure the styles are visible
+                            await pause(() => { console_log_it('wait 10s', '[YOUTUBE] '); }, SPEED * 2); // 1 second delay for safety
+                            if (forKids) {
+                                await waitFor(async () => {
+                                    console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.yesKidsRadioButton], '[YOUTUBE] currentelement');
+                                    return getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.yesKidsRadioButton];
+                                });
+                                await moveMouse(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.yesKidsRadioButton]);
+                            }
+                            else {
+                                await waitFor(async () => {
+                                    console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.notKidsRadioButton], '[YOUTUBE] currentelement');
+                                    return getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.notKidsRadioButton];
+                                });
+                                await moveMouse(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.notKidsRadioButton]);
+                            }
+                            await pause(async () => {
+                                console_log_it("Performing left click...", '[YOUTUBE] state');
+                                await mouseClick(); // Performs a left-click.
+                            }, 1000); // 1 second delay for safety
+                            await pause(async () => {
+                                console_log_it("Performing left click...", '[YOUTUBE] state');
+                                await mouseClick(); // Performs a left-click.
+                            }, 1000); // 1 second delay for safety
+                        }
+                        {
+                            await pause(() => { console_log_it('wait 10s', '[YOUTUBE] '); }, SPEED); // 1 second delay for safety
+                            await waitFor(async () => {
+                                console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.nextButton], '[YOUTUBE] currentelement');
+                                return getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.nextButton];
+                            });
+                            await moveMouse(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.nextButton]);
+                            await pause(async () => {
+                                console_log_it("Performing left click...", '[YOUTUBE] state');
+                                await mouseClick(); // Performs a left-click.
+                            }, 1000); // 1 second delay for safety
+                        }
+                        {
+                            await pause(() => { console_log_it('wait 10s', '[YOUTUBE] '); }, SPEED); // 1 second delay for safety
+                            await waitFor(async () => {
+                                console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.nextButton], '[YOUTUBE] currentelement');
+                                return getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.nextButton];
+                            });
+                            await moveMouse(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.nextButton]);
+                            await pause(async () => {
+                                console_log_it("Performing left click...", '[YOUTUBE] state');
+                                await mouseClick(); // Performs a left-click.
+                            }, 1000); // 1 second delay for safety
+                        }
+                        {
+                            await pause(() => { console_log_it('wait 10s', '[YOUTUBE] '); }, SPEED); // 1 second delay for safety
+                            await waitFor(async () => {
+                                console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.nextButton], '[YOUTUBE] currentelement');
+                                return getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.nextButton];
+                            });
+                            await moveMouse(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.nextButton]);
+                            await pause(async () => {
+                                console_log_it("Performing left click...", '[YOUTUBE] state');
+                                await mouseClick(); // Performs a left-click.
+                            }, 1000); // 1 second delay for safety
+                        }
+                        {
+                            await pause(() => { console_log_it('wait 10s', '[YOUTUBE] '); }, SPEED); // 1 second delay for safety
+                            await waitFor(async () => {
+                                console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.scheduleButton], '[YOUTUBE] currentelement');
+                                return getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.scheduleButton];
+                            });
+                            await moveMouse(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.scheduleButton]);
+                            await pause(async () => {
+                                console_log_it("Performing left click...", '[YOUTUBE] state');
+                                await mouseClick(); // Performs a left-click.
+                            }, 1000); // 1 second delay for safety
+                        }
+                        {
+                            await pause(() => { console_log_it('wait 10s', '[YOUTUBE] '); }, SPEED); // 1 second delay for safety
+                            await waitFor(async () => {
+                                console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.dateField]);
+                                return getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.dateField];
+                            });
+                            await moveMouse(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.dateField]);
+                            await pause(async () => {
+                                console_log_it("Performing left click...", '[YOUTUBE] state');
+                                await mouseClick(); // Performs a left-click.
+                            }, 1000); // 1 second delay for safety
+                            clearAllText();
+                            const today = new Date();
+                            let additionalDays = extractVersionNumber(fileForUpload);
+                            if (!additionalDays) {
+                                additionalDays = 0;
+                            }
+                            else {
+                                additionalDays = additionalDays * 90;
+                            }
+                            const future = addDays(today, additionalDays + dateOffset);
+                            let dayt = (formatMMDDYYYY(future));
+                            await pasteText(dayt);
+                            if (PER_DAY) {
+                                dateOffset += i % PER_DAY === 0 ? 1 : 0;
+                            }
+                            else {
+                                dateOffset++;
+                            }
+                        }
+                        {
+                            await pause(() => { console_log_it('wait 10s', '[YOUTUBE] '); }, SPEED); // 1 second delay for safety
+                            await workflowOp(async () => {
+                                console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.scheduleNavButton], ' [YOUTUBE] currentelement');
+                                return getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.scheduleNavButton];
+                            }, async () => {
+                                await moveMouse(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.scheduleNavButton]);
+                            }, async () => {
+                                console_log_it("Performing left click...", '[YOUTUBE] state');
+                                await mouseClick(); // Performs a left-click.
+                            }, async () => {
+                                console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.closeButton], '[YOUTUBE] currentelement');
+                                return getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.closeButton];
+                            }, 10, SPEED * 2, '[YOUTUBE] workflowOp');
+                        }
+                        {
+                            await pause(() => { console_log_it('wait 10s'); }, SPEED); // 1 second delay for safety
+                            await waitFor(async () => {
+                                console_log_it(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.closeButton], '[YOUTUBE] currentelement');
+                                return getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.closeButton];
+                            });
+                            await moveMouse(getContext().position?.[MODES.YOUTUBE]?.[YOUTUBE_SELECTORS.closeButton]);
+                            await pause(async () => {
+                                console_log_it("Performing left click...");
+                                await mouseClick(); // Performs a left-click.
+                            }, 1000); // 1 second delay for safety
+                        }
+                        count += 1;
+                        if (count % 3 === 0 && count > 0) {
+                            console_log_it(`Waiting for ${(SPEED / 1000) * 12} seconds before next upload...`, '[YOUTUBE] state');
+                            await pause(() => { }, SPEED * 6); // Wait before next upload
+                            refreshScreen(robot);
+                            await pause(() => { }, SPEED * 6); // Wait before next upload
+                        }
+                    }
+                }
+                currentSources[i].uploaded = true;
+                saveProjectFile(currentSourceFilePath, overAllCurrentSources);
+                1;
+            }
+            success = true;
+        }
+        catch (e) {
+            // write out callstack
+            console_log_it(e.message, '[YOUTUBE] error');
+            console_log_it(e.stack, '[YOUTUBE] errorstatement');
+            console_log_it(`[YOUTUBE] error: ${JSON.stringify(e)}`, 'error');
+            console_log_it(e, '[YOUTUBE] error_');
+            attempts--;
+            success = false;
+            await pause(() => { }, SPEED * 6); // Wait before next upload
+            refreshScreen(robot);
+            await pause(() => { }, SPEED * 6); // Wait before next upload
+        }
+    }
+    console_log_it('[DONE] operate youtube', '[YOUTUBE] func');
+    console_log_it(`[DONE] Operating Youtube with mode: ${get(KEYS.mode)}`, '[YOUTUBE] running-mode');
+}
+export async function fileModalOperate(filePath) {
+    if (process.platform !== 'win32') {
+        await pause(() => { goToFolderShortcut(); }, 3000);
+    }
+    await pause(() => { console_log_it('wait 10s'); }, 5000); // 1 second delay for safety
+    await pasteText(filePath);
+    await pause(() => { pressReturn(); }, 5000); // 1 second delay for safety
+    if (process.platform !== 'win32') {
+        await pause(() => { pressReturn(); }, 5000);
+    }
+}
+/**
+ * Formats a Date object as MM/DD/YYYY.
+ * @param {Date} date
+ * @returns {string}
+ */
+function formatMMDDYYYY(date) {
+    const mm = String(date.getMonth() + 1).padStart(2, '0');
+    const dd = String(date.getDate()).padStart(2, '0');
+    const yyyy = date.getFullYear();
+    return `${mm}/${dd}/${yyyy}`;
+}
+/**
+ * Adds `days` to the given Date and returns a new Date.
+ * @param {Date} date
+ * @param {number} days
+ * @returns {Date}
+ */
+function addDays(date, days) {
+    const result = new Date(date);
+    result.setDate(result.getDate() + days);
+    return result;
+}
+/**
+ * Immediately scrolls the mouse wheel.
+ *
+ * @param {number} x  — horizontal scroll amount (positive → right, negative → left)
+ * @param {number} y  — vertical scroll amount   (positive → down,  negative → up)
+ */
+export function scroll(x = 0, y = 0) {
+    robot.scrollMouse(x, y);
+}
+/**
+ * Sends the macOS “Go to Folder” shortcut (⌘+⇧+G) to the frontmost window.
+ */
+function goToFolderShortcut() {
+    // Optional: slow down the key events if your system is too fast
+    robot.setKeyboardDelay(100);
+    // Tap “g” with Command and Shift held
+    robot.keyTap('g', ['command', 'shift']);
+}
+function getSunoPosition(key) {
+    return getContext().position?.[MODES.SUNO_FILM]?.[key] || {};
+}
+export async function operateSunoFilmMouse() {
+    const SPEED = parseInt(get(KEYS.speed) || '5000') || 5000;
+    let output_path = path.join(get(KEYS.current_folder), getItem('sourceFile'));
+    let suno_film_audio_tracks_per = parseInt(get(KEYS.suno_film_audio_tracks_per) || '2') || 2;
+    console_log_it(`Starting at ${new Date(Date.now()).toISOString()} ---`, 'suno film');
+    let projects = readProjectFile(output_path);
+    try {
+        for (let i = 0; i < projects.length; i++) {
+            console_log_it(buildProgressBar(i + 1, projects.length, 20), 'suno-film-progress-bar');
+            let project = projects[i];
+            console_log_it(`Starting project ${project?.name}`, 'Suno Film [state]');
+            project.song_sources = project?.song_sources || [];
+            if (project.song_sources.length < suno_film_audio_tracks_per) {
+                let style = project?.style || 'spoken word, slow';
+                if (get(KEYS.ignoreStyle) === 'yes') {
+                    style = 'spoken word, slow';
+                }
+                const lyric = project?.lines?.join('\n');
+                if (!lyric) {
+                    console_log_it(`has no lyrics`, project.name);
+                    continue;
+                }
+                console_log_it(`Has lyrics ${lyric.length}`, 'Suno Film [state]');
+                const name = project.name;
+                suno_film_audio_tracks_per = parseInt(get(KEYS.suno_film_audio_tracks_per) || '2') || 2;
+                const count = suno_film_audio_tracks_per;
+                set(KEYS.current_song_name, name);
+                getContext().list_selectors = Object.values({
+                    [getSunoCompletedSongs(name)]: getSunoCompletedSongs(name),
+                    [getSunoRequestedSongs(name)]: getSunoRequestedSongs(name)
+                });
+                let all_project_songs_ready = false;
+                console_log_it(`Loading suno state`, 'Suno Film [state]');
+                let suno_state = get(KEYS.suno_state) || {};
+                console_log_it(`${Object.keys(suno_state)?.length}`, 'incomingSongs');
+                let project_song_states = Object.values(suno_state).filter(x => x.name === project.name);
+                let song_states = project_song_states.filter(x => x.name === project.name && x.ready && x.url && x.lyric);
+                let skipsong = false;
+                let skip = false;
+                do {
+                    skipsong = false;
+                    suno_state = get(KEYS.suno_state) || {};
+                    all_project_songs_ready = false;
+                    ({
+                        suno_state,
+                        project_song_states,
+                        all_project_songs_ready,
+                        song_states,
+                        skip
+                    } = processSunoState(suno_state, project_song_states, project, all_project_songs_ready, song_states));
+                    if (skip) {
+                        skipsong = true;
+                    }
+                    // Move to title
+                    if ((project.song_sources?.length || 0) < count && !skipsong) {
+                        {
+                            const { left, top, height, width } = getSunoPosition(SUNO_SELECTORS.styles);
+                            if (left && top) {
+                                const targetX = left + chrome_offsets.x + (width / 2);
+                                const targetY = top + chrome_offsets.y + (height / 4);
+                                robot.moveMouseSmooth(targetX, targetY);
+                                scroll(0, -1000); // Scroll down to make sure the styles are visible
+                                await pause(() => { }, SPEED * 2); // Wait for the scroll to complete
+                            }
+                        }
+                        {
+                            const { left, top, height, width } = getSunoPosition(SUNO_SELECTORS.styles_tags);
+                            if (left && top) {
+                                const targetX = left + chrome_offsets.x + (width / 2);
+                                const targetY = top + chrome_offsets.y + (height / 4);
+                                robot.moveMouseSmooth(targetX, targetY);
+                                scroll(0, -1000); // Scroll down to make sure the styles are visible
+                                await pause(() => { }, SPEED * 2); // Wait for the scroll to complete
+                            }
+                        }
+                        {
+                            const { left, top, height, width } = getSunoPosition(SUNO_SELECTORS.title);
+                            // Define the target coordinates (x, y)
+                            const targetX = left + chrome_offsets.x + (width / 2);
+                            const targetY = top + chrome_offsets.y + (height / 4);
+                            console_log_it(`Moving mouse to (${targetX}, ${targetY})...`);
+                            // Move the mouse smoothly to the target coordinates
+                            console_log_it(`name`, 'Suno Film [state]');
+                            robot.moveMouseSmooth(targetX, targetY);
+                            await pause(() => {
+                                console_log_it("Performing left click...");
+                                robot.mouseClick(); // Performs a left-click.
+                                robot.mouseClick(); // Performs a left-click.
+                            }, 1000); // 1 second delay for safety
+                            clearAllText();
+                            await pasteText(name);
+                        }
+                        {
+                            const { left, top, height, width } = getSunoPosition(SUNO_SELECTORS.styles);
+                            if (left && top) {
+                                const targetX = left + chrome_offsets.x + (width / 2);
+                                const targetY = top + chrome_offsets.y + (height / 4);
+                                robot.moveMouseSmooth(targetX, targetY);
+                                scroll(0, 1000); // Scroll down to make sure the styles are visible
+                                await pause(() => { }, SPEED * 2); // Wait for the scroll to complete
+                            }
+                        }
+                        {
+                            const { left, top, height, width } = getSunoPosition(SUNO_SELECTORS.styles_tags);
+                            if (left, top) {
+                                const targetX = left + chrome_offsets.x + (width / 2);
+                                const targetY = top + chrome_offsets.y + (height / 4);
+                                robot.moveMouseSmooth(targetX, targetY);
+                                scroll(0, 1000); // Scroll down to make sure the styles are visible
+                                await pause(() => { }, SPEED * 2); // Wait for the scroll to complete
+                            }
+                        }
+                        // Move to lyrics
+                        {
+                            const { left, top, height, width } = getSunoPosition(SUNO_SELECTORS.lyrics);
+                            // Define the target coordinates (x, y)
+                            const targetX = left + chrome_offsets.x + (width / 2);
+                            const targetY = top + chrome_offsets.y + (height / 4);
+                            console_log_it(`Moving mouse to (${targetX}, ${targetY})...`);
+                            console_log_it(`lyrics`, 'Suno Film [state]');
+                            // Move the mouse smoothly to the target coordinates
+                            robot.moveMouseSmooth(targetX, targetY);
+                            await pause(() => {
+                                console_log_it("Performing left click...");
+                                robot.mouseClick(); // Performs a left-click.
+                            }, 1000); // 1 second delay for safety
+                            clearAllText();
+                            if (lyric) {
+                                await pasteText(lyric);
+                            }
+                        }
+                        {
+                            const { left, top, height, width } = getSunoPosition(SUNO_SELECTORS.styles);
+                            const targetX = left + chrome_offsets.x + (width / 2);
+                            const targetY = top + chrome_offsets.y + (height / 4);
+                            robot.moveMouseSmooth(targetX, targetY);
+                            scroll(0, 1000); // Scroll down to make sure the styles are visible
+                            await pause(() => { }, SPEED * 2); // Wait for the scroll to complete
+                        }
+                        {
+                            const { left, top, height, width } = getSunoPosition(SUNO_SELECTORS.styles_tags);
+                            if (left, top) {
+                                const targetX = left + chrome_offsets.x + (width / 2);
+                                const targetY = top + chrome_offsets.y + (height / 4);
+                                robot.moveMouseSmooth(targetX, targetY);
+                                scroll(0, 1000); // Scroll down to make sure the styles are visible
+                                await pause(() => { }, SPEED * 2); // Wait for the scroll to complete
+                            }
+                        }
+                        // Move to styles
+                        {
+                            const { left, top, height, width } = getSunoPosition(SUNO_SELECTORS.styles);
+                            if (left && top) {
+                                const targetX = left + chrome_offsets.x + (width / 2);
+                                const targetY = top + chrome_offsets.y + (height / 4);
+                                console_log_it(`Moving mouse to (${targetX}, ${targetY})...`);
+                                console_log_it(`styles`, 'Suno Film [state]');
+                                // Move the mouse smoothly to the target coordinates
+                                robot.moveMouseSmooth(targetX, targetY);
+                                await pause(() => {
+                                    console_log_it("Performing left click...");
+                                    robot.mouseClick(); // Performs a left-click.
+                                }, 1000); // 1 second delay for safety
+                                clearAllText();
+                                await pasteText(style);
+                            }
+                        }
+                        {
+                            const { left, top, height, width } = getSunoPosition(SUNO_SELECTORS.styles_tags);
+                            if (left && top) {
+                                const targetX = left + chrome_offsets.x + (width / 2);
+                                const targetY = top + chrome_offsets.y + (height / 4);
+                                console_log_it(`Moving mouse to (${targetX}, ${targetY})...`);
+                                console_log_it(`styles`, 'Suno Film [state]');
+                                // Move the mouse smoothly to the target coordinates
+                                robot.moveMouseSmooth(targetX, targetY);
+                                await pause(() => {
+                                    console_log_it("Performing left click...");
+                                    robot.mouseClick(); // Performs a left-click.
+                                }, 1000); // 1 second delay for safety
+                                clearAllText();
+                                await pasteText(style);
+                            }
+                        }
+                        // Move to button
+                        {
+                            const { left, top, height, width } = getSunoPosition(SUNO_SELECTORS.createbtn);
+                            // Define the target coordinates (x, y)
+                            const targetX = left + chrome_offsets.x + (width / 2);
+                            const targetY = top + chrome_offsets.y + (height / 4);
+                            console_log_it(`Moving mouse to (${targetX}, ${targetY})...`);
+                            // Move the mouse smoothly to the target coordinates
+                            let clickcount = Math.max(0, (count - song_states.length) / 2);
+                            console_log_it(`create button`, 'Suno Film [state]');
+                            for (let k = 0; k < clickcount; k++) {
+                                robot.moveMouseSmooth(targetX, targetY);
+                                await pause(() => {
+                                    console_log_it("Performing left click...");
+                                    robot.mouseClick(); // Performs a left-click.
+                                }, 10000); // 1 second delay for safety
+                            }
+                        }
+                    }
+                    {
+                        await pause(() => {
+                            console_log_it("Wait to download songs...");
+                        }, 10 * 1000); // 1 second delay for safety
+                    }
+                    project.lyrics = song_states.map(v => v.lyric);
+                    project.song_sources = song_states.map(v => v.url);
+                    console_log_it(`${Object.keys(suno_state)?.length}`, 'incomingSongs');
+                    let clickcount = Math.max(0, (count - song_states.length) / 2);
+                    let maxwaits = 100;
+                    all_project_songs_ready = !clickcount;
+                    while (!all_project_songs_ready && maxwaits && !skipsong) {
+                        await pause(() => { }, 10 * 1000);
+                        maxwaits--;
+                        console_log_it(maxwaits, 'maxwaits');
+                        console_log_it(`waiting ${maxwaits}, all_project_songs_ready ${all_project_songs_ready}`, 'Suno Film [state]');
+                        ({ suno_state, project_song_states, all_project_songs_ready, song_states, skip } = processSunoState(suno_state, project_song_states, project, all_project_songs_ready, song_states));
+                        skipsong = skip;
+                        console_log_it(`get(KEYS.current_song_name) == name: ${get(KEYS.current_song_name) == name}, !all_project_songs_ready ${!all_project_songs_ready} || song_states.length < count ${song_states.length < count}, ${song_states.length} ${count}`, 'Suno Film [state]');
+                    }
+                    saveProjectFile(output_path, projects);
+                } while (get(KEYS.current_song_name) == name && (!all_project_songs_ready || song_states.length < count) && !skipsong);
+            }
+            else {
+                let all_project_songs_ready = false;
+                let suno_state = get(KEYS.suno_state) || {};
+                let project_song_states = Object.values(suno_state).filter(x => x.name === project.name);
+                let song_states = project_song_states.filter(x => x.name === project.name && x.ready && x.url && x.lyric);
+                let skip = false;
+                all_project_songs_ready = false;
+                ({
+                    suno_state,
+                    project_song_states,
+                    all_project_songs_ready,
+                    song_states,
+                    skip
+                } = processSunoState(suno_state, project_song_states, project, all_project_songs_ready, song_states));
+                console_log_it(`skip: ${skip}`, 'Suno Film [state]');
+                console_log_it(`there are enough songs ${project.title || project.name} ${project?.song_sources?.length}< ${project?.song_sources?.length}`, 'song count');
+            }
+        }
+        console_log_it(`Finished all`, 'Suno Film [state]');
+    }
+    catch (e) {
+        console_log_it(`Error in operateSunoFilmMouse: ${e.message}`, 'suno film error message');
+        console_log_it(`Stack: ${e.stack}`, 'suno film error stack');
+        console_log_it('something went wrong with ', 'suno film error');
+        console_log_it(e, 'suno film error _');
+    }
+    saveProjectFile(output_path, projects);
+    console_log_it(`Done at ${new Date(Date.now()).toISOString()} ---`, 'suno film');
+}
+export async function operateSunoMouse(body) {
+    let song_ideas = readProjectFile(get(KEYS.sunofileName));
+    for (let i = 0; i < song_ideas.length; i++) {
+        const { style, lyric, name, count = 10 } = song_ideas[i];
+        set(KEYS.current_song_name, name);
+        getContext().list_selectors = Object.values({
+            [getSunoCompletedSongs(name)]: getSunoCompletedSongs(name),
+            [getSunoRequestedSongs(name)]: getSunoRequestedSongs(name)
+        });
+        let dir = path.join(get(KEYS.current_folder), 'audio', fix(name));
+        let files = await getFiles(dir);
+        setItem(KEYS.suno_current_name, name);
+        let requestedSongs = getContext().all_positions?.[getSunoRequestedSongs(name)]?.length || 0;
+        let existingSongs = getContext().all_positions?.[getSunoCompletedSongs(name)]?.length || 0;
+        console_log_it(`requestedSongs: ${requestedSongs}`);
+        console_log_it(`existingSongs: ${existingSongs}`);
+        let downloadFailed = false;
+        let targetfolder = path.join(get(KEYS.sunoDownloadFolder), fix(name));
+        let fileCount = fs.existsSync(targetfolder) ? fs.readdirSync(targetfolder).length : 0;
+        if (fileCount < count) {
+            do {
+                downloadFailed = false;
+                // Move to title
+                if (requestedSongs < count) {
+                    {
+                        const { left, top, height, width } = body[SUNO_SELECTORS.title];
+                        // Define the target coordinates (x, y)
+                        const targetX = left + chrome_offsets.x + (width / 2);
+                        const targetY = top + chrome_offsets.y + (height / 4);
+                        console_log_it(`title`, 'operateSunoMouse[state]');
+                        // Move the mouse smoothly to the target coordinates
+                        robot.moveMouseSmooth(targetX, targetY);
+                        await pause(() => {
+                            console_log_it("Performing left click...");
+                            robot.mouseClick(); // Performs a left-click.
+                            robot.mouseClick(); // Performs a left-click.
+                        }, 1000); // 1 second delay for safety
+                        clearAllText();
+                        await pasteText(name);
+                    }
+                    // Move to lyrics
+                    {
+                        const { left, top, height, width } = body[SUNO_SELECTORS.lyrics];
+                        // Define the target coordinates (x, y)
+                        const targetX = left + chrome_offsets.x + (width / 2);
+                        const targetY = top + chrome_offsets.y + (height / 4);
+                        console_log_it(`Moving mouse to (${targetX}, ${targetY})...`);
+                        console_log_it(`lyrics`, 'operateSunoMouse[state]');
+                        // Move the mouse smoothly to the target coordinates
+                        robot.moveMouseSmooth(targetX, targetY);
+                        await pause(() => {
+                            console_log_it("Performing left click...");
+                            robot.mouseClick(); // Performs a left-click.
+                        }, 1000); // 1 second delay for safety
+                        clearAllText();
+                        if (lyric) {
+                            await pasteText(lyric);
+                        }
+                    }
+                    // Move to styles
+                    {
+                        const { left, top, height, width } = body[SUNO_SELECTORS.styles];
+                        // Define the target coordinates (x, y)
+                        const targetX = left + chrome_offsets.x + (width / 2);
+                        const targetY = top + chrome_offsets.y + (height / 4);
+                        console_log_it(`Moving mouse to (${targetX}, ${targetY})...`);
+                        console_log_it(`styles`, 'operateSunoMouse[state]');
+                        // Move the mouse smoothly to the target coordinates
+                        robot.moveMouseSmooth(targetX, targetY);
+                        await pause(() => {
+                            console_log_it("Performing left click...");
+                            robot.mouseClick(); // Performs a left-click.
+                        }, 1000); // 1 second delay for safety
+                        clearAllText();
+                        await pasteText(style);
+                    }
+                    // Move to button
+                    {
+                        const { left, top, height, width } = body[SUNO_SELECTORS.createbtn];
+                        // Define the target coordinates (x, y)
+                        const targetX = left + chrome_offsets.x + (width / 2);
+                        const targetY = top + chrome_offsets.y + (height / 4);
+                        console_log_it(`Moving mouse to (${targetX}, ${targetY})...`);
+                        // Move the mouse smoothly to the target coordinates
+                        robot.moveMouseSmooth(targetX, targetY);
+                        console_log_it(`create button`, 'operateSunoMouse[state]');
+                        await pause(() => {
+                            console_log_it("Performing left click...");
+                            robot.mouseClick(); // Performs a left-click.
+                        }, 1000); // 1 second delay for safety
+                    }
+                }
+                {
+                    await pause(() => {
+                        console_log_it("Wait to download songs...");
+                    }, 10 * 1000); // 1 second delay for safety
+                }
+                requestedSongs = getContext().all_positions?.[getSunoRequestedSongs(name)]?.length || 0;
+                existingSongs = getContext().all_positions?.[getSunoCompletedSongs(name)]?.length || 0;
+                console_log_it(`requestedSongs: ${requestedSongs}`);
+                console_log_it(`existingSongs: ${existingSongs}`);
+                let song_list = get(KEYS.song_list);
+                if (song_list) {
+                    let urls = song_list;
+                    for (let i = 0; i < urls.length; i++) {
+                        try {
+                            await downloadWithPython(urls[i], get(KEYS.sunoDownloadFolder), fix(name));
+                            console_log_it('All done!');
+                        }
+                        catch (err) {
+                            downloadFailed = true;
+                            console.error('Download script failed:', err);
+                        }
+                    }
+                }
+            } while ((!files?.length && count > existingSongs) || downloadFailed);
+        }
+    }
+}
+/**
+ * Selects all text in the current focused field and deletes it.
+ */
+function clearAllText() {
+    // On macOS use 'command', otherwise 'control'
+    const modifier = process.platform === 'darwin' ? 'command' : 'control';
+    // Give a tiny pause to ensure focus is correct (optional)
+    robot.setKeyboardDelay(50);
+    // Select all
+    robot.keyTap('a', modifier);
+    // Delete selected text
+    // On some apps you may prefer 'backspace' instead of 'delete'
+    robot.keyTap('delete');
+}
+export function isNoCharacterMode() {
+    return get(KEYS.project_character) === '--no character--';
+}
+export function ignoreCharacters() {
+    return get(KEYS.ignoreCharacters) === 'yes';
+}
+export async function operateMouse(position, signal, progress) {
+    try {
+        console_log_it(`Midjourney Progress: START`, 'midjourney-progress');
+        const { left, top, height, width } = position;
+        const root_folder = get(KEYS.current_folder);
+        const name = getItem('sourceFile');
+        let skipping = 0;
+        let filesToProcess = [name];
+        filesToProcess = getFilesToProcess(name, filesToProcess, root_folder);
+        let e1 = [];
+        filesToProcess.filter(x => x.endsWith('.json')).forEach((fileP) => {
+            console_log_it(fileP, 'file to operate');
+            let projects = readProjectFile(path.join(root_folder, fileP));
+            let sub_lyric_projects = projects.map(t => {
+                return t.lyrics || [];
+            }).flat();
+            if (sub_lyric_projects?.length) {
+                e1 = [...e1, ...sub_lyric_projects];
+            }
+            else if (projects?.length) {
+                e1 = [...e1, ...projects];
+            }
+        });
+        // {
+        //     height: 23.99147605895996,
+        //     left: 419.8692932128906,
+        //     top: 379.8948860168457,
+        //     width: 1170.241455078125
+        //   }
+        // Define the target coordinates (x, y)
+        const targetX = left + chrome_offsets.x + (width / 2);
+        const targetY = top + chrome_offsets.y + (height / 4);
+        console_log_it(`Moving mouse to (${targetX}, ${targetY})...`);
+        // Move the mouse smoothly to the target coordinates
+        robot.moveMouseSmooth(targetX, targetY);
+        // Wait briefly before clicking to ensure the mouse has reached the target.
+        await pause(() => {
+            console_log_it("Performing left click...");
+            robot.mouseClick(); // Performs a left-click.
+        }, 1000); // 1 second delay for safety
+        for (let i = 0; i < e1.length; i++) {
+            const SPEED = parseInt(get(KEYS.speed) || 5000) || 5000;
+            let section = e1[i];
+            const { portrait_prompt, prompts, characters } = section;
+            console_log_it(`Midjourney Progress: ${buildProgressBar(i + 1, e1.length, 20)}`, 'midjourney-progress');
+            if (portrait_prompt) {
+                if (!get(KEYS.project_character) || isNoCharacterMode() || ignoreCharacters()) {
+                    let waitedAmount = 0;
+                    waitedAmount = await waitForQueuedRenders(waitedAmount, SPEED);
+                    let existing_images = findExistingImage(portrait_prompt, get(KEYS.ratio));
+                    if (!existing_images?.length) {
+                        await pasteText(portrait_prompt);
+                        await pause(() => { }, WAIT_FACTOR * 13000);
+                        robot.keyTap('enter');
+                        await pause(() => { }, WAIT_FACTOR * 15000);
+                    }
+                    else {
+                        console_log_it(`skipping: ${portrait_prompt}`);
+                    }
+                }
+            }
+            for (let j = 0; j < prompts.length; j++) {
+                console_log_it(`Midjourney Progress: ${buildProgressBar(j + 1, prompts.length, 20)}`, 'midjourney-progress|prompts');
+                let prompt = prompts[j];
+                console_log_it(`${characters?.[i]}`, 'character');
+                console_log_it(`${get(KEYS.project_character)}`, 'project_character');
+                if (!ignoreCharacters())
+                    if (get(KEYS.project_character)) {
+                        if ((isNoCharacterMode() && !characters?.[i]?.trim())) {
+                            console_log_it('not skipping', 'skipping');
+                        }
+                        else if (characters?.[i] !== get(KEYS.project_character)) {
+                            console_log_it(`skipping ${skipping}`, 'skipping');
+                            skipping++;
+                            continue;
+                        }
+                    }
+                    else {
+                        console_log_it('not skipping', 'skipping');
+                    }
+                let waitedAmount = 0;
+                waitedAmount = await waitForQueuedRenders(waitedAmount, SPEED);
+                console_log_it(`${characters?.[i]} === ${get(KEYS.project_character)}`, 'check match');
+                console_log_it('didnt skip', 'skipping');
+                if (!findExistingImage(prompt, get(KEYS.ratio)).length) {
+                    if (typeof prompt === 'string') {
+                        await pasteText(prompt);
+                        await pause(() => { }, WAIT_FACTOR * 12000);
+                        robot.keyTap('enter');
+                        await pause(() => { }, WAIT_FACTOR * 15000);
+                    }
+                    else {
+                        console_log_it(prompt);
+                    }
+                }
+                else {
+                    console_log_it(`skipping: ${prompt}`);
+                }
+            }
+            console_log_it(`Midjourney prompts:DONE`, 'midjourney-progress|prompts');
+        }
+    }
+    catch (e) {
+        console_log_it(`Error in operateMouse: ${JSON.stringify(e)}`, 'error');
+        console_log_it(e, 'error_');
+    }
+    console_log_it(`Midjourney Progress: DONE`, 'midjourney-progress');
+}
+function findExistingImage(prompt, ratio) {
+    let job_file = fs.readFileSync(get_jobs_path(), 'utf-8').split('\n').map(v => JSON.parse(v))
+        .filter(job => getDetectOrientation(job) === ratio).filter(f => `${f.full_command}`.includes(prompt));
+    let jobs = job_file.filter(f => `${f.full_command}`.includes(prompt));
+    let imageFiles = jobs.map((job) => {
+        return findFilesWithString(get(KEYS.images_folder), job.id);
+    }).flat();
+    return imageFiles.filter(fileName => {
+        return true;
+    });
+}
+export function getSunoCompletedSongs(name) {
+    console_log_it(`suno_current_name: ${name}`);
+    return `[aria-label="${name}"]@@@button||Edit`;
+}
+export function getSunoRequestedSongs(name) {
+    console_log_it(`suno_current_name: ${name}`);
+    return `[aria-label="${name}"]`;
+}
+//# sourceMappingURL=operations.js.map