flow-frame-core 0.1.0

package/dist/utils.js

@@ -0,0 +1,1517 @@
+import path from 'path';
+import { windowManager } from 'node-window-manager';
+import http from 'http';
+import fs from 'fs';
+import os from 'os';
+import extract from 'extract-zip';
+import https from 'https';
+import { URL } from 'url';
+import { imageSize } from 'image-size';
+import progressStream from 'progress-stream';
+import ffmpeg from 'fluent-ffmpeg';
+import robot from 'robotjs';
+import { getItem, isDocker, setItem } from './storage.js';
+import { KEYS, MODES } from './constants.js';
+import archiver from 'archiver';
+import { execSync } from 'child_process';
+const console_context = {};
+export function console_log_it(text, cat) {
+    console_context[cat || 'general'] = text;
+    if (true) {
+        return;
+    }
+    if (isDocker()) {
+        console.log(`${cat}: ${text}`);
+        return;
+    }
+    console.clear();
+    Object.entries(console_context).map(([key, value]) => {
+        if (console_context[`mode-filter`]) {
+            if (key.includes(console_context[`mode-filter`])) {
+                if (typeof value === 'object') {
+                    return console.log(`${key}: ${JSON.stringify(value, null, 3)}`);
+                }
+                return console.log(`${key}: ${value}`);
+            }
+            return;
+        }
+        return console.log(`${key}: ${value}`);
+    });
+}
+export function getConsoleContext() {
+    return console_context;
+}
+const input_bar = '[id="desktop_input_bar"]';
+const MIDJOURNEY_SELECTOR = {
+    queued: 'span||Queued',
+    [input_bar]: input_bar,
+    addImageBtn: '[id="AddImageIcon"]',
+    promptImage: '[src*="https://cdn.midjourney.com/u/',
+    chooseAnImage: 'button span||Choose a file',
+    starting: 'div[id="pageScroll"] span.relative||Starting...',
+    completing: 'div[id="pageScroll"] span.relative||!Complete',
+    firstImage: 'div[id="pageScroll"] a',
+    buttonSearchBtn: 'div button||Search',
+    searchInput: '[id="search-input"]',
+    downloadButton: 'button[title="Download Video for Social Media"] svg',
+    lightboxPrompt: '[id="lightboxPrompt"] p',
+    firstImageCell: '[id="pageScroll"] div div:first-child div.relative.flex-center',
+    ilikeRadiobutton: 'button span||I like this video',
+    iNeutralRadiobutton: `button span||I'm neutral on this video`,
+    buttonAnimate: 'button||Animate',
+    videoButton: 'div a video',
+    videoRatio: 'button[title="Image aspect ratio"] span||ar 91:51',
+    videoRatio2: 'button[title="Image aspect ratio"] span||ar 143:256',
+    videoRatio3: 'button[title="Image aspect ratio"] span||ar 51:91',
+    videoRatio4: 'button[title="Image aspect ratio"] span||ar 77:58',
+    videoRatio5: 'button[title="Image aspect ratio"] span||ar 3:2',
+    videoRatio6: 'button[title="Image aspect ratio"] span||ar 2:3',
+    optionsButton: 'button[title="Options"]',
+    optionsDownloadButton: 'button div span||Download for Social',
+    useText: 'h2||Use'
+};
+export function processSunoState(suno_state, project_song_states, project, all_project_songs_ready, song_states) {
+    suno_state = get(KEYS.suno_state) || {};
+    const sunoStateValues = Object.values(suno_state);
+    project_song_states = sunoStateValues.filter(x => x.name === project.name);
+    let unready_songs = project_song_states.filter(x => !x.ready || !x.url || !x.lyric);
+    all_project_songs_ready = !project_song_states.some(x => !x.ready || !x.url || !x.lyric);
+    console_log_it(`unready songs ${all_project_songs_ready} ${project_song_states.filter(x => !x.ready || !x.url || !x.lyric).length}`, 'unready-songs');
+    song_states = project_song_states.filter(x => x.name === project.name && x.url && x.lyric);
+    project.lyrics = project.lyrics || [];
+    project.lyrics = unique([...project.lyrics, ...song_states.map(v => v.lyric)], v => v.songId);
+    project.song_sources = unique([...project.song_sources, ...song_states.map(v => v.url)], v => v);
+    console_log_it(`${project.song_sources.length}`, 'soung_source_count');
+    console_log_it(`${song_states.length}/${project_song_states.length}`, 'song_progress');
+    console_log_it(buildProgressBar(song_states.length, project_song_states.length), 'song_progress_bar');
+    let skip = false;
+    if (unready_songs.length > 3) {
+        skip = true;
+        // Do something if there are more than  3 unready songs
+        console_log_it(`There are more than 3 unready songs: ${unready_songs.length}`, 'unready-songs');
+    }
+    return { suno_state, project_song_states, all_project_songs_ready, song_states, skip };
+}
+/**
+ * Detect whether an image is portrait, landscape, or square.
+ *
+ * @param {string|Buffer} input – either a path to the image file, or a Buffer
+ * @returns {'portrait'|'landscape'|'square'}
+ */
+const doCache = {};
+function getDetectOrientation({ width, height }) {
+    if (width > height) {
+        return 'landscape';
+    }
+    if (height > width) {
+        return 'portrait';
+    }
+    return 'square';
+}
+function detectOrientation(input) {
+    // image-size will accept a file path or a Buffer
+    // image-size will accept a file path or a Buffer
+    if (doCache[input]) {
+        return doCache[input];
+    }
+    const { width, height } = imageSize(fs.readFileSync(input));
+    if (width > height) {
+        console.log('landscape');
+        doCache[input] = 'landscape';
+        return doCache[input];
+    }
+    if (height > width) {
+        console.log('portrait');
+        doCache[input] = 'portrait';
+        return doCache[input];
+    }
+    console.log('square');
+    doCache[input] = 'square';
+    return doCache[input];
+}
+/**
+ * Returns one or more random element(s) from the given array.
+ * @param {any[]} arr — the array to pick from
+ * @param {number} [count=1] — how many random elements to select
+ * @returns {any|any[]|undefined} a single element if count is 1 (or undefined if empty),
+ *                                otherwise an array of up to count elements
+ */
+function selectRandom(arr, count = 1) {
+    if (!Array.isArray(arr)) {
+        throw new TypeError('selectRandom expects an array');
+    }
+    if (!Number.isInteger(count) || count < 1) {
+        throw new TypeError('selectRandom expects count as a positive integer');
+    }
+    const len = arr.length;
+    if (len === 0) {
+        // empty array: undefined for single, empty array for multiple
+        return count === 1 ? undefined : [];
+    }
+    if (count === 1) {
+        // single pick
+        const idx = Math.floor(Math.random() * len);
+        return [arr[idx]];
+    }
+    // multiple picks — shuffle a copy of the array
+    const shuffled = arr.slice();
+    for (let i = shuffled.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+    }
+    // return up to count items
+    return shuffled.slice(0, Math.min(count, len));
+}
+/**
+ * Node.js script to extract all zip files from a source folder to a destination folder.
+ *
+ * Usage: node unzip-all.js <source_folder> <destination_folder>
+ * If not provided, defaults are:
+ *   source_folder: './zips'
+ *   destination_folder: './unzipped'
+ *
+ * Required dependency: extract-zip (install via: npm install extract-zip)
+ */
+async function unzip(sourceFolder, destinationFolder, subfolder = '') {
+    // const sourceFolder = process.argv[2] || 'F:\\ai\\historical figures\\zips';
+    // const destinationFolder = process.argv[3] || 'F:\\ai\\historical figures\\images';
+    // const subfolder = process.argv[4] || '';
+    // Read all files from the source folder
+    console.log(`unziping....`);
+    console.log(`sourceFolder: ${sourceFolder}`);
+    console.log(`destinationFolder: ${destinationFolder}`);
+    console.log(`subfolder: ${subfolder}`);
+    let files = fs.readdirSync(sourceFolder);
+    // Filter for .zip files
+    const zipFiles = files.filter(file => path.extname(file).toLowerCase() === '.zip' && file.startsWith("midjourney_session_"));
+    if (zipFiles.length === 0) {
+        console.log('No zip files found in', sourceFolder);
+        return Promise.resolve([]);
+    }
+    // Process each zip file
+    let result = Promise.resolve();
+    (zipFiles.map(file => {
+        result = result.then(() => {
+            const zipPath = path.join(sourceFolder, file);
+            // Create a destination folder for the current zip file (based on its name)
+            const extractTo = path.join(destinationFolder);
+            console.log(`Extracting to: ${extractTo}`);
+            // Ensure the destination subfolder exists
+            fs.mkdirSync(extractTo, { recursive: true });
+            // Extract the zip file
+            return extract(zipPath, { dir: extractTo })
+                .then(() => {
+                console.log(`Extracted ${file} to ${extractTo}`);
+                fs.unlinkSync(zipPath);
+            })
+                .catch(err => {
+                console.error(`Error extracting ${file}:`, err);
+            });
+        });
+    }));
+    return result;
+}
+async function unzipFile(zipPath, extractTo) {
+    await ensureDir(extractTo);
+    return extract(zipPath, { dir: extractTo })
+        .then(() => {
+        console.log(`Extracted ${zipPath} to ${extractTo}`);
+        fs.unlinkSync(zipPath);
+    })
+        .catch(err => {
+        console.error(`Error extracting ${zipPath}:`, err);
+    });
+}
+/**
+ * Remove characters not allowed in filenames and replace whitespace with underscores.
+ * @param {string} name
+ * @returns {string}
+ */
+function sanitizeFileName(name) {
+    // remove reserved Windows filename characters: < > : " / \ | ? *
+    const illegalRe = /[<>:,.\'"\/\\|?*]/g;
+    // collapse one or more whitespace characters into a single underscore
+    const whitespaceRe = /\s+/g;
+    return name
+        .replace(illegalRe, '')
+        .replace(whitespaceRe, '_');
+}
+/**
+ * Finds the screen position and size (bounds) of an Explorer window
+ * that appears to be displaying a specific folder address.
+ *
+ * @param {string} folderAddress - The full path of the folder to find (e.g., "C:\\Users\\YourUser\\Documents").
+ * @returns {Object|null} The window bounds { x, y, width, height } if found, or null if not.
+ */
+function findExplorerWindowPosition(folderName) {
+    // Extract the folder name from the provided address.
+    // Retrieve all open windows.
+    const windows = windowManager.getWindows();
+    for (const win of windows) {
+        // Check if the window belongs to explorer.exe.
+        const procPath = win.process?.path;
+        const title = win.getTitle().toLowerCase();
+        if (title === folderName) {
+            console.log(`title: ${title}`);
+            console.log(`procPath: ${procPath}`);
+            return (win.getBounds());
+        }
+    }
+    // If no matching Explorer window is found, return null.
+    return null;
+}
+async function locateExtensionIcon(filePath) {
+    // const filePath = path.resolve(__dirname, './chromeExtensionIconImage.png');
+    const fileName = path.basename(filePath);
+    // Get file size
+    const stats = await fs.promises.stat(filePath);
+    // Generate a unique multipart boundary
+    const boundary = '----NodeMultipartBoundary' + Date.now();
+    const lb = '\r\n';
+    // Build the multipart header and footer
+    const partHeader = `--${boundary}${lb}` +
+        `Content-Disposition: form-data; name="template"; filename="${fileName}"${lb}` +
+        `Content-Type: application/octet-stream${lb}${lb}`;
+    const partFooter = `${lb}--${boundary}--${lb}`;
+    // Calculate total content length
+    const contentLength = Buffer.byteLength(partHeader) +
+        stats.size +
+        Buffer.byteLength(partFooter);
+    const options = {
+        hostname: '127.0.0.1',
+        port: 5020,
+        path: '/find-image',
+        method: 'POST',
+        headers: {
+            'Content-Type': `multipart/form-data; boundary=${boundary}`,
+            'Content-Length': contentLength
+        }
+    };
+    return new Promise((resolve, reject) => {
+        const req = http.request(options, (res) => {
+            let body = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => {
+                body += chunk;
+            });
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(body);
+                    resolve(json);
+                }
+                catch (err) {
+                    reject(new Error('Invalid JSON response'));
+                }
+            });
+        });
+        req.on('error', reject);
+        // write header
+        req.write(partHeader);
+        // pipe the file
+        const fileStream = fs.createReadStream(filePath);
+        fileStream.pipe(req, { end: false });
+        fileStream.on('end', () => {
+            // write footer and end request
+            req.end(partFooter);
+        });
+        fileStream.on('error', reject);
+    });
+}
+/**
+ * saveProjectFile
+ * ----------------
+ * Saves an array of objects to `filePath` as newline-delimited JSON.
+ * Each element in `array` is stringified and written on its own line.
+ *
+ * @param {string} filePath  - Path to the file where data will be written.
+ * @param {any[]} array      - Array of serializable objects.
+ */
+function saveProjectFile(filePath, array) {
+    // Serialize each object to a JSON string, join by newline
+    const data = array.map(obj => JSON.stringify(obj)).join('\n');
+    fs.writeFileSync(filePath, data, 'utf8');
+}
+/**
+ * readProjectFile
+ * ----------------
+ * Reads `filePath` synchronously and returns an array of objects.
+ * - If the file content (after trimming) starts with '[', parse it as a JSON array.
+ * - Otherwise, split on '\n', parse each non-empty line as a JSON object, and return an array of those objects.
+ *
+ * @param {string} filePath  - Path to the JSON file to read.
+ * @returns {any[]}          - Array of objects read from the file.
+ */
+function readProjectFile(filePath) {
+    // Read whole file as UTF-8 text
+    const content = fs.readFileSync(filePath, 'utf8').trim();
+    if (!content) {
+        // Empty file: return empty array
+        return [];
+    }
+    if (content.startsWith('[')) {
+        // File is a JSON array
+        return JSON.parse(content);
+    }
+    else {
+        // Treat as newline-delimited JSON objects
+        return content
+            .split('\n')
+            .filter(line => line.trim() !== '')
+            .map(line => JSON.parse(line));
+    }
+}
+/**
+ * Counts the number of files (not directories) in the Downloads folder.
+ * @returns {number} The count of files.
+ */
+function countFilesInDownloads() {
+    const downloadsPath = getDownloadsFolder();
+    try {
+        const entries = fs.readdirSync(downloadsPath);
+        let fileCount = 0;
+        for (const entry of entries) {
+            const fullPath = path.join(downloadsPath, entry);
+            if (fs.statSync(fullPath).isFile()) {
+                fileCount++;
+            }
+        }
+        return fileCount;
+    }
+    catch (err) {
+        console.error(`Failed to read ${downloadsPath}:`, err);
+        return 0;
+    }
+}
+/**
+ * Schedule `callback` to run in `timeoutMs` milliseconds,
+ * unless you call the returned cancel function first.
+ *
+ * @param   {() => void} callback
+ * @param   {number}      timeoutMs
+ * @returns {() => void}  cancel function
+ */
+function ifYouDontFinish(callback, timeoutMs) {
+    const timerId = setTimeout(callback, timeoutMs);
+    return () => clearTimeout(timerId);
+}
+/**
+ * Find all files in the Downloads folder that start with
+ * "social_aporter_" and end with ".mp4".
+ *
+ * @returns {Promise<string[]>} Array of matching file names
+ */
+async function findSocialPorterVideos() {
+    const downloadsDir = getDownloadsFolder();
+    try {
+        const entries = fs.readdirSync(downloadsDir);
+        return entries.filter(name => name.startsWith('social_') &&
+            name.toLowerCase().endsWith('.mp4'));
+    }
+    catch (err) {
+        console_log_it(`Failed to read directory ${downloadsDir}:`, 'findSocialPorterVideos');
+        return [];
+    }
+}
+/**
+ * Move an array of filenames (from findSocialPorterVideos)
+ * from the Downloads folder into the given target directory.
+ *
+ * @param {string[]} files    - array of filenames (e.g. ['social_aporter_1.mp4', ...])
+ * @param {string}   targetDir - absolute or relative path to destination directory
+ */
+async function moveSocialPorterVideos(files, targetDir) {
+    try {
+        console_log_it(`moveSocialPorterVideos`, 'social_move');
+        const downloadsDir = getDownloadsFolder();
+        console_log_it(downloadsDir, 'social_move');
+        // ensure the target directory exists
+        fs.mkdirSync(targetDir, { recursive: true });
+        console_log_it(targetDir, 'social_move');
+        console_log_it(`files.length : ${files.length}`, 'social_move_length');
+        for (const file of files) {
+            const srcPath = path.join(downloadsDir, file);
+            const destPath = path.join(targetDir, file);
+            try {
+                // first try a fast rename
+                fs.renameSync(srcPath, destPath);
+                console_log_it(`✔ Renamed: ${file}`, 'social_move');
+            }
+            catch (err) {
+                if (err.code === 'EXDEV') {
+                    // cross-device, so copy then delete
+                    try {
+                        fs.copyFileSync(srcPath, destPath);
+                        fs.unlinkSync(srcPath);
+                        console_log_it(`✔ Copied+Deleted across devices: ${file}`, 'social_move');
+                    }
+                    catch (copyErr) {
+                        console_log_it(`✖ Failed to copy+delete ${file}: ${copyErr}`, 'social_move');
+                    }
+                }
+                else {
+                    console_log_it(`✖ Failed to rename ${file}: ${err}`, 'social_move');
+                }
+            }
+        }
+    }
+    catch (e) {
+        console_log_it(`✖ Failed to move social_porter videos: ${e}`, 'social_move');
+    }
+}
+function getDownloadsFolder() {
+    const home = os.homedir();
+    if (process.platform === 'win32') {
+        // Windows: check registry for the Downloads known folder
+        try {
+            const raw = execSync('reg query "HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders" /v "{374DE290-123F-4565-9164-39C4925E467B}"').toString();
+            // parse the REG_SZ value and expand %USERPROFILE%
+            const match = raw.match(/REG_SZ\s+(.*)/);
+            if (match) {
+                return match[1].replace('%USERPROFILE%', home);
+            }
+        }
+        catch (e) {
+            // fall back if registry read fails
+        }
+    }
+    // macOS & Linux: check XDG spec first
+    if (process.platform !== 'win32') {
+        const cfg = path.join(home, '.config', 'user-dirs.dirs');
+        if (fs.existsSync(cfg)) {
+            const content = fs.readFileSync(cfg, 'utf8');
+            const line = content.match(/^XDG_DOWNLOAD_DIR=(.*)$/m);
+            if (line) {
+                // strip quotes and ${HOME}
+                return line[1]
+                    .replace(/^"(.*)"$/, '$1')
+                    .replace('$HOME', home);
+            }
+        }
+    }
+    // default fallback
+    return path.join(home, 'Downloads');
+}
+/**
+ * Reads all entries in `dirPath` and returns those whose names start with `prefix`.
+ * @param {string} dirPath - The directory to scan.
+ * @param {string} prefix - The filename prefix to match.
+ * @returns {Promise<string[]>} - Resolves to an array of matching filenames.
+ */
+async function getFilesStartingWith(dirPath, prefix) {
+    try {
+        // Read all entries in the directory
+        const entries = await fs.promises.readdir(dirPath);
+        // Filter for names that start with the prefix
+        const matches = entries.filter(name => name.startsWith(prefix));
+        return matches;
+    }
+    catch (err) {
+        // You might want to handle ENOENT (directory not found) specially
+        console.error(`Error reading directory ${dirPath}:`, err);
+        throw err;
+    }
+}
+/**
+ * Reads all entries in `dirPath` and returns those whose names start with `prefix`.
+ * @param {string} dirPath - The directory to scan.
+ * @returns {Promise<string[]>} - Resolves to an array of matching filenames.
+ */
+async function getFiles(dirPath) {
+    try {
+        // Read all entries in the directory
+        const entries = await fs.promises.readdir(dirPath);
+        // Filter for names that start with the prefix
+        const matches = entries;
+        return matches;
+    }
+    catch (err) {
+        return [];
+    }
+}
+/**
+ * Synchronously deletes the file at `filePath`.
+ * @param {string} filePath - The path to the file to delete.
+ */
+function deleteFileSync(filePath) {
+    try {
+        fs.unlinkSync(filePath);
+        console.log(`Deleted: ${filePath}`);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            console.warn(`File not found, could not delete: ${filePath}`);
+        }
+        else {
+            console.error(`Error deleting file ${filePath}:`, err);
+            throw err; // rethrow if it's a different error
+        }
+    }
+}
+/**
+ * Download a single file to the given destination path.
+ * @param {string} fileUrl - The URL of the file to download.
+ * @param {string} destPath - The full path (including filename) to save the file.
+ * @returns {Promise<void>}
+ */
+function downloadFile(fileUrl, destPath, onProgress) {
+    return new Promise((resolve, reject) => {
+        const urlObj = new URL(fileUrl);
+        const client = urlObj.protocol === 'https:' ? https : http;
+        client.get(urlObj, response => {
+            if (response.statusCode !== 200) {
+                return reject(new Error(`Failed to get '${fileUrl}' (status: ${response.statusCode})`));
+            }
+            // Make sure the destination folder exists
+            fs.mkdirSync(path.dirname(destPath), { recursive: true });
+            // Read total size from headers
+            const total = parseInt(response.headers['content-length'] || '0', 10);
+            // Create the progress stream
+            const prog = progressStream({
+                length: total,
+                time: 100 // emit 'progress' events every 100ms
+            });
+            prog.on('progress', progress => {
+                if (onProgress) {
+                    onProgress(`Downloading ${fileUrl}… ${progress.percentage.toFixed(2)}%`, progress.percentage);
+                }
+            });
+            // Pipe response → prog → fileStream
+            const fileStream = fs.createWriteStream(destPath);
+            response.pipe(prog).pipe(fileStream);
+            fileStream.on('finish', () => {
+                fileStream.close(resolve);
+            });
+            fileStream.on('error', err => {
+                fs.unlink(destPath, () => reject(err));
+            });
+        })
+            .on('error', err => {
+            reject(err);
+        });
+    });
+}
+/**
+ * Read and parse all .json files in a directory, including newline-delimited JSON.
+ *
+ * @param {string} dirPath - Path to folder containing your .json files
+ * @returns {Promise<Object[]>} - Resolves to an array of all parsed objects
+ */
+async function readJsonFiles(dirPath) {
+    return new Promise((resolve, reject) => {
+        let files;
+        try {
+            files = fs.readdirSync(dirPath);
+        }
+        catch (err) {
+            return reject(err);
+        }
+        // Filter to .json files
+        const jsonFiles = files.filter(f => path.extname(f).toLowerCase() === '.json');
+        if (jsonFiles.length === 0) {
+            return resolve([]);
+        }
+        const results = [];
+        jsonFiles.forEach(filename => {
+            const fullPath = path.join(dirPath, filename);
+            results.push(fullPath);
+        });
+        resolve(results);
+    });
+}
+/**
+ * Get the last‑modified time of a file as a comparable number.
+ *
+ * @param {string} filePath - Path to the file
+ * @returns {number}        - milliseconds since UNIX epoch
+ */
+function getLastModifiedTimestampSync(filePath) {
+    // resolve to an absolute path (optional but avoids surprises)
+    const fullPath = path.resolve(filePath);
+    // statSync will throw if the file doesn't exist or is inaccessible
+    const stats = fs.statSync(fullPath);
+    // use getTime() for maximum compatibility across Node versions
+    return stats.mtime.getTime();
+}
+/**
+ * Download multiple files into a target folder.
+ * @param {string[]} urls - Array of file URLs to download.
+ * @param {string} destFolder - Path to the folder where files should be saved.
+ * @returns {Promise<string[]>} - Resolves to an array of the downloaded file paths.
+ */
+async function downloadFiles(urls, destFolder) {
+    // Ensure destination folder exists
+    fs.mkdirSync(destFolder, { recursive: true });
+    const downloadPromises = urls.map(async (fileUrl) => {
+        // Derive a filename from the URL
+        const pathname = new URL(fileUrl).pathname;
+        let filename = path.basename(pathname);
+        if (!filename) {
+            // Fallback if URL ends with a slash
+            filename = `file-${Date.now()}`;
+        }
+        const destPath = path.join(destFolder, filename);
+        if (!fs.existsSync(destPath))
+            await downloadFile(fileUrl, destPath, null).catch(e => {
+                console.error(e);
+            });
+        return destPath;
+    });
+    // Wait for all downloads to complete
+    return Promise.all(downloadPromises);
+}
+/**
+ * Ensures that the directory at `dirPath` exists.
+ * Creates it (and any missing parent directories) if it doesn’t.
+ * @param {string} dirPath
+ * @returns {Promise<void>}
+ */
+async function ensureDir(dirPath) {
+    return fs.promises.mkdir(dirPath, { recursive: true });
+}
+function unique(array, selector = x => x) {
+    const seen = new Set();
+    return array.filter(item => {
+        const key = selector(item);
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+/**
+ * Strip out punctuation and lowercase for comparison.
+ */
+function normalize(str) {
+    return str.replace(/[^a-z0-9]/gi, '').toLowerCase();
+}
+/**
+ * Align every lyric line to its timed words, treating any number of
+ * trailing '\n' on a word as exactly one line break.
+ *
+ * @param {string[]} lines
+ * @param {{ word: string, start_s: number, end_s: number }[]} alignedWords
+ * @returns {{
+*   line: string,
+*   start_s: number|null,
+*   end_s: number|null,
+*   words: { text: string, start_s: number|null, end_s: number|null }[]
+* }[]}
+*/
+function alignLinesToWords(alignedWords) {
+    // 1) Bucket the alignedWords into per-line arrays by '\n+' marker:
+    const wordsByLine = [];
+    let lineIdx = 0;
+    wordsByLine[lineIdx] = [];
+    alignedWords.forEach(({ word, start_s, end_s }) => {
+        // detect one-or-more trailing newlines
+        const isLineEnd = /\n+\"?$/.test(word);
+        // strip ALL trailing newlines for matching
+        const cleanWord = word.replace(/\n+$/, '');
+        wordsByLine[lineIdx].push({ text: cleanWord, start_s, end_s });
+        // if there was at least one '\n', advance to next bucket
+        if (isLineEnd) {
+            lineIdx++;
+            wordsByLine[lineIdx] = [];
+        }
+    });
+    // 2) Now align each lyric line to its bucket of timed words
+    return wordsByLine.map((line, i) => {
+        // const tokens = line.split(/\s+/).filter(Boolean);
+        const timed = wordsByLine[i] || [];
+        const aligned = timed || [];
+        // compute line start/end as min/max of word timings
+        const starts = timed.map(w => w.start_s).filter(x => x != null);
+        const ends = timed.map(w => w.end_s).filter(x => x != null);
+        return {
+            line: line.map(v => v.text.trim()).join(' '),
+            start_s: starts.length ? Math.min(...starts) : null,
+            end_s: ends.length ? Math.max(...ends) : null,
+            start: starts.length ? Math.min(...starts) : null,
+            end: ends.length ? Math.max(...ends) : null,
+            words: aligned
+        };
+    });
+}
+function extractFileNameFromUrl(url) {
+    try {
+        const urlObj = new URL(url);
+        return path.basename(urlObj.pathname);
+    }
+    catch (error) {
+        console.error('Invalid URL:', url, error);
+        return null;
+    }
+}
+function findFileInDirectoryHasInWithAndEndingWith(dirPath, start, end) {
+    try {
+        const files = fs.readdirSync(dirPath);
+        return files.find(file => file.includes(start) && file.endsWith(end)) || null;
+    }
+    catch (err) {
+        console.error(`Error reading directory ${dirPath}:`, err);
+        return null;
+    }
+}
+export function getFilesToProcess(name, filesToProcess, root_folder) {
+    switch (get(KEYS.procedure)) {
+    }
+    return filesToProcess;
+}
+export function getMediaFileDuration(filePath) {
+    return new Promise((resolve, reject) => {
+        ffmpeg.ffprobe(filePath, (err, metadata) => {
+            if (err)
+                return reject(err);
+            if (metadata && metadata.format && typeof metadata.format.duration === 'number') {
+                resolve(metadata.format.duration); // duration in seconds
+            }
+            else if (metadata && metadata.streams) {
+                // If duration is not in format, try to find it in any stream (audio or video)
+                const stream = metadata.streams.find(s => s.codec_type === 'audio' || s.codec_type === 'video');
+                if (stream && typeof stream.duration === 'number') {
+                    resolve(Math.round(stream.duration));
+                }
+                else {
+                    reject(new Error('Could not determine media duration.'));
+                }
+            }
+            else {
+                reject(new Error('Could not determine media duration.'));
+            }
+        });
+    });
+}
+// Returns the duration of a video file in seconds using ffmpeg
+function getVideoDuration(filePath) {
+    return new Promise((resolve, reject) => {
+        ffmpeg.ffprobe(filePath, (err, metadata) => {
+            if (err)
+                return reject(err);
+            if (metadata && metadata.format && typeof metadata.format.duration === 'number') {
+                // Find the first video stream for dimensions
+                const videoStream = (metadata.streams || []).find(s => s.codec_type === 'video');
+                const width = videoStream ? videoStream.width : undefined;
+                const height = videoStream ? videoStream.height : undefined;
+                resolve({
+                    duration: metadata.format.duration,
+                    width,
+                    height
+                });
+            }
+            else {
+                reject(new Error('Could not determine video duration.'));
+            }
+        });
+    });
+}
+export function getVideoDimensions(filePath) {
+    return new Promise((resolve, reject) => {
+        ffmpeg.ffprobe(filePath, (err, metadata) => {
+            if (err)
+                return reject(err);
+            const videoStream = (metadata.streams || []).find(s => s.codec_type === 'video');
+            if (videoStream) {
+                resolve({
+                    width: videoStream.width,
+                    height: videoStream.height
+                });
+            }
+            else {
+                reject(new Error('No video stream found.'));
+            }
+        });
+    });
+}
+/**
+ * Sends the “refresh” key combo:
+ *  - macOS → ⌘+R
+ *  - Windows/Linux → F5
+ */
+function refreshScreen(robot) {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        // macOS: Command+R
+        robot.keyTap('r', 'command');
+    }
+    else {
+        // Windows & most Linux desktops: F5
+        robot.keyTap('f5');
+    }
+}
+/**
+ * Reads files in a directory and sorts them by updated_at (most recent first).
+ * @param {string} dirPath - The path to the directory.
+ * @returns {Promise<string[]>} - A Promise that resolves to an array of filenames sorted by updated_at.
+ */
+async function getSortedFilesByUpdatedAt(dirPath) {
+    return new Promise((resolve, reject) => {
+        fs.readdir(dirPath, (err, files) => {
+            if (err)
+                return reject(err);
+            const filePaths = files.filter(x => x.endsWith('.png')).map(file => path.join(dirPath, file));
+            Promise.all(filePaths.map(filePath => fs.promises.stat(filePath).then(stats => ({
+                file: path.basename(filePath),
+                updatedAt: stats.mtime.getTime()
+            })))).then(fileStats => {
+                const sorted = fileStats
+                    .sort((a, b) => b.updatedAt - a.updatedAt)
+                    .map(f => f.file);
+                resolve(sorted);
+            }).catch(reject);
+        });
+    });
+}
+/**
+ * Asynchronously writes text to the clipboard, waits for a short delay,
+ * and then simulates a paste operation.
+ *
+ * @param {string} text - The text to copy to the clipboard and paste.
+ */
+async function pasteText(text) {
+    const clipboardy = (await import('clipboardy')).default;
+    // Asynchronously write the text to the clipboard.
+    await clipboardy.writeSync(`${text}`);
+    // Wait 100ms to ensure the clipboard is updated.
+    await new Promise(resolve => setTimeout(resolve, 100));
+    // Determine the correct modifier key based on your platform.
+    const modifier = process.platform === 'darwin' ? 'command' : 'control';
+    // Simulate the paste operation (Ctrl+V on Windows/Linux, Command+V on macOS).
+    robot.keyTap('v', modifier);
+}
+/**
+ * Waits for a condition to become true within a specified time window.
+ * Polls every 10 seconds by default.
+ *
+ * @param {() => boolean} condition - The condition to check.
+ * @param {number} maxWaitMs - Maximum time to wait (default: 60 seconds).
+ * @param {number} intervalMs - Polling interval (default: 10 seconds).
+ * @returns {Promise<void>} Resolves when condition is met, rejects if time runs out.
+ */
+async function waitFor(condition, maxWaitMs = 120000, intervalMs = 100) {
+    const deadline = Date.now() + maxWaitMs;
+    const sleep = (ms) => new Promise(res => setTimeout(res, ms));
+    console_log_it(condition.toString(), 'wait_for_condition');
+    while (Date.now() < deadline) {
+        try {
+            if (await condition())
+                return;
+        }
+        catch (e) { }
+        await sleep(intervalMs);
+    }
+    console_log_it('condition not met within timeout', 'wait_for');
+    throw new Error('Condition not met within timeout: ' + condition.toString());
+}
+async function workflowOp(testCondition, moveMouse, action, checkCondition, attemps = 10, interval = 1000, console_context = 'workflowOp') {
+    let attempts = 0;
+    while (attempts < attemps) {
+        try {
+            // Check the test condition
+            const currentElement = await testCondition();
+            if (currentElement) {
+                // Move the mouse to the element
+                await moveMouse();
+                // Perform the action (e.g., click)
+                await action();
+                // Check the condition after the action
+                const conditionMet = await checkCondition();
+                if (conditionMet) {
+                    console_log_it('Condition met after action', console_context);
+                    return true; // Exit if the condition is met
+                }
+                else {
+                    console_log_it('Condition not met after action, retrying...', console_context);
+                }
+            }
+            else {
+                console_log_it('Test condition not met, retrying...', console_context);
+            }
+        }
+        catch (error) {
+            console_log_it(`Error in workflowOp: ${error.message}`, console_context);
+        }
+        // Wait before the next attempt
+        await new Promise(resolve => setTimeout(resolve, interval));
+        attempts++;
+    }
+    console_log_it('Max attempts reached, exiting workflowOp', console_context);
+    return false; // Return false if the condition was never met
+    // Example usage:
+    // const MODES = getContext().mode;
+}
+async function isThere(condition, maxWaitMs = 6000, intervalMs = 100) {
+    try {
+        await waitFor(condition, maxWaitMs, intervalMs);
+    }
+    catch (e) {
+        console_log_it('is there failed ', 'isThere');
+        console_log_it(e, 'isThere-error');
+        return false;
+    }
+    return true;
+}
+function pressReturn() {
+    // You can also use 'return' on some platforms, but 'enter' is most common
+    robot.keyTap('enter');
+}
+/**
+ * Pause execution for a specified delay and then execute a callback.
+ * @param {Function} callback - The function to execute after the delay.
+ * @param {number} delay - The delay in milliseconds.
+ * @returns {Promise<void>}
+ */
+function pause(callback, delay) {
+    return new Promise((resolve) => {
+        setTimeout(async () => {
+            await callback();
+            resolve(undefined);
+        }, delay);
+    });
+}
+/**
+ * Selects all text in the current focused field and deletes it.
+ */
+export 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');
+}
+async function mouseClick() {
+    return new Promise((resolve) => {
+        robot.mouseToggle('down');
+        setTimeout(() => {
+            robot.mouseToggle('up');
+            resolve(undefined);
+        }, 100);
+    });
+}
+async function waitForQueuedRenders(waitedAmount, SPEED) {
+    while (getModePosition()?.[MIDJOURNEY_SELECTOR.queued]) {
+        console_log_it(`'waited amount ${waitedAmount}'`, 'waited_amount');
+        waitedAmount++;
+        await pause(() => { }, SPEED);
+    }
+    return waitedAmount;
+}
+/**
+ * Extracts the version number from a string containing '_version_${number}'.
+ * Returns the number as an integer, or null if not found.
+ * @param {string} str
+ * @returns {number|null}
+ */
+function extractVersionNumber(str) {
+    const match = str.match(/_version_(\d+)/);
+    return match ? parseInt(match[1], 10) : null;
+}
+const context = {
+    positions: null,
+    position: {},
+    last_updated: 0,
+    last_used: 0
+};
+function getContext() {
+    return context;
+}
+function setContext(key, value) {
+    context[key] = value;
+    context.last_updated = Date.now();
+    context.last_used = Date.now();
+}
+;
+/// ─── UTIL ──────────────────────────────────────────────────────────────────────
+/**
+ * Replace placeholders in a template string with values from a data object.
+ * Placeholders are in the form {key}.
+ *
+ * @param {string} template  — the template string, e.g. "Hello, {name}!"
+ * @param {Object} data      — an object mapping keys to values, e.g. { name: "Alice" }
+ * @returns {string}         — the interpolated string
+ */
+function applyTemplate(template, data) {
+    return template.replace(/\{([^}]+)\}/g, (_, key) => {
+        // If the key exists in data, replace it; otherwise leave it blank (or you could throw/error)
+        return data[key] != null ? data[key] : "";
+    });
+}
+// grab the first non-internal IPv4 on your machine
+function getLocalIp() {
+    const ifaces = os.networkInterfaces();
+    for (const list of Object.values(ifaces)) {
+        for (const iface of list) {
+            if (iface.family === 'IPv4' && !iface.internal) {
+                return iface.address;
+            }
+        }
+    }
+    throw new Error('No LAN IPv4 address found');
+}
+/**
+ * Build a text progress bar.
+ *
+ * @param {number} index      - Current progress (0 … length)
+ * @param {number} length     - Total units of work
+ * @param {number} charLength - Total characters in the bar
+ * @returns {string}          - Progress bar string
+ */
+function buildProgressBar(index, length, charLength = 20) {
+    if (length <= 0 || charLength <= 0) {
+        console_log_it(`Invalid progress bar parameters`, 'progress_bar');
+        return '';
+    }
+    // Clamp index between 0 and length
+    const clampedIndex = Math.max(0, Math.min(index, length));
+    // How many characters should be "filled"?
+    const filledCount = Math.floor((clampedIndex / length) * charLength);
+    // Build the bar
+    const filledPart = '█'.repeat(filledCount);
+    const emptyPart = '_'.repeat(charLength - filledCount);
+    return filledPart + emptyPart + `[${index}/${length}]`;
+}
+function getMode() {
+    if (!getContext().mode) {
+        getContext().mode = getItem('mode');
+    }
+    if (getContext().mode) {
+        return getContext().mode;
+    }
+    return MODES.MIDJOURNEY;
+}
+function getModePosition() {
+    if (getContext()?.position && getContext().position[getMode()]) {
+        return getContext().position[getMode()];
+    }
+    return null;
+}
+/**
+ * Recursively searches for files containing a specific string in their name.
+ * @param dir The root directory to search.
+ * @param searchString The string to search for in file names.
+ * @returns An array of relative file paths.
+ */
+function findFilesWithString(dir, searchString) {
+    const results = [];
+    function search(currentPath) {
+        const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentPath, entry.name);
+            if (entry.isDirectory()) {
+                search(fullPath); // Recurse into subdirectory
+            }
+            else if (entry.name.includes(searchString)) {
+                const relativePath = path.relative(dir, fullPath);
+                results.push(relativePath);
+            }
+        }
+    }
+    search(dir);
+    return results;
+}
+function getModePositionKey(key) {
+    return getModePosition()?.[key];
+}
+function lerp(start, end, t) {
+    return start + (end - start) * t;
+}
+function get(key) {
+    if (!getContext()?.[key]) {
+        getContext()[key] = getItem(key);
+    }
+    console_log_it(`${getItem(key)}`.substring(0, 200), key);
+    return getItem(key);
+}
+function set(key, value) {
+    setItem(key, value);
+    console_log_it(`${value}`.substring(0, 200), key);
+    setContext(key, getItem(key));
+}
+function get_jobs_path() {
+    if (!getContext().jobsPath) {
+        getContext().jobsPath = get(KEYS.jobs_folder);
+    }
+    if (getContext().jobsPath) {
+        return path.join(get(KEYS.jobs_folder), 'source.jsonl');
+    }
+    throw 'jobs_path not set';
+}
+const jobs_context = {
+    jobs: []
+};
+function getJobsContext() {
+    return jobs_context;
+}
+function findJobs(prompt) {
+    console_log_it(`running:  read jobs: ${get_jobs_path()}`, 'jobs');
+    jobs_context.jobs = fs.readFileSync(get_jobs_path(), 'utf-8').split('\n').map(v => JSON.parse(v));
+    let jobs = jobs_context.jobs.filter(f => `${(f.full_command)}`.includes((prompt)));
+    return jobs;
+}
+function findVideoJobs(prompt) {
+    console_log_it(`running:  read jobs: ${get_jobs_path()}`, 'jobs');
+    let jobs = findJobs(prompt);
+    return jobs.filter(job => {
+        return job.event_type === "video_diffusion" || job.event_type === "video_extended";
+    });
+}
+;
+/**
+ * Create a zip file containing specified folders
+ * @param {string} rootFolder - Root directory path
+ * @param {string[]} folderNames - Array of folder names relative to root folder
+ * @param {string} zipFileName - Name of the zip file to create (without extension)
+ * @param {Object} options - Additional options
+ * @returns {Promise<string>} - Path to the created zip file
+ */
+async function createZipFromFolders(rootFolder, folderNames, zipFileName, options = {}) {
+    const { compressionLevel = 1, // 0-9, higher = more compression but slower
+    onProgress = null, // Callback for progress updates
+    includeEmptyFolders = true, filter = null // Function to filter files: (filePath, stat) => boolean
+     } = options;
+    return new Promise((resolve, reject) => {
+        try {
+            console_log_it(`Creating zip file: ${zipFileName}.zip`, 'create_zip_folders');
+            console_log_it(`Root folder: ${rootFolder}`, 'create_zip_folders');
+            console_log_it(`Folders to zip: ${folderNames.join(', ')}`, 'create_zip_folders');
+            // Ensure root folder exists
+            if (!fs.existsSync(rootFolder)) {
+                throw new Error(`Root folder does not exist: ${rootFolder}`);
+            }
+            // Create zip file path
+            // make sure zipFileName doesn't double up on extensions
+            const zipFilePath = path.join(rootFolder, zipFileName.endsWith('.zip') ? zipFileName : `${zipFileName}.zip`);
+            // Create write stream for the zip file
+            const output = fs.createWriteStream(zipFilePath);
+            const archive = archiver('zip', {
+                zlib: { level: compressionLevel }
+            });
+            // Track progress
+            let totalBytes = 0;
+            const folderStats = [];
+            // Handle stream events
+            output.on('close', () => {
+                console_log_it(`Zip file created successfully: ${zipFilePath}`, 'create_zip_folders');
+                console_log_it(`Total size: ${(archive.pointer() / 1024 / 1024).toFixed(2)} MB`, 'create_zip_folders');
+                resolve(zipFilePath);
+            });
+            output.on('error', (err) => {
+                console_log_it(`Error writing zip file: ${err.message}`, 'create_zip_folders');
+                reject(err);
+            });
+            archive.on('error', (err) => {
+                console_log_it(`Error creating archive: ${err.message}`, 'create_zip_folders');
+                reject(err);
+            });
+            archive.on('progress', (progress) => {
+                if (onProgress) {
+                    const progressPercent = totalBytes > 0 ? Math.round((progress.fs.processedBytes / totalBytes) * 100) : 0;
+                    onProgress({
+                        type: 'compress',
+                        processedBytes: progress.fs.processedBytes,
+                        totalBytes: totalBytes,
+                        progress: progressPercent,
+                        entriesProcessed: progress.entries.processed,
+                        entriesTotal: progress.entries.total
+                    });
+                }
+            });
+            // Pipe archive data to the file
+            archive.pipe(output);
+            // Validate and add each folder
+            const validFolders = [];
+            for (const folderName of folderNames) {
+                const folderPath = path.join(rootFolder, folderName);
+                if (!fs.existsSync(folderPath)) {
+                    console_log_it(`Warning: Folder does not exist, skipping: ${folderName}`, 'create_zip_folders');
+                    continue;
+                }
+                const stat = fs.statSync(folderPath);
+                if (!stat.isDirectory()) {
+                    console_log_it(`Warning: Path is not a directory, skipping: ${folderName}`, 'create_zip_folders');
+                    continue;
+                }
+                validFolders.push({ name: folderName, path: folderPath });
+                // Calculate folder size for progress tracking
+                const folderSize = calculateFolderSize(folderPath);
+                folderStats.push({ name: folderName, size: folderSize });
+                totalBytes += folderSize;
+            }
+            if (validFolders.length === 0) {
+                reject(new Error('No valid folders found to zip'));
+                return;
+            }
+            console_log_it(`Total estimated size: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`, 'create_zip_folders');
+            // Add each folder to the archive using a more reliable method
+            const addFolderRecursive = (folderPath, zipPath) => {
+                try {
+                    const files = fs.readdirSync(folderPath, { withFileTypes: true });
+                    for (const file of files) {
+                        const fullPath = path.join(folderPath, file.name);
+                        const zipFilePath = path.join(zipPath, file.name).replace(/\\/g, '/'); // Normalize path separators
+                        if (file.isDirectory()) {
+                            // Recursively add subdirectory
+                            addFolderRecursive(fullPath, zipFilePath);
+                        }
+                        else if (file.isFile()) {
+                            // Apply filter if provided
+                            if (filter) {
+                                const stat = fs.statSync(fullPath);
+                                if (!filter(fullPath, stat)) {
+                                    continue;
+                                }
+                            }
+                            // Add individual file
+                            console_log_it(`Adding file: ${zipFilePath}`, 'create_zip_folders');
+                            archive.file(fullPath, { name: zipFilePath });
+                        }
+                    }
+                }
+                catch (error) {
+                    console_log_it(`Error processing folder ${folderPath}: ${error.message}`, 'create_zip_folders');
+                    throw error;
+                }
+            };
+            // Add each valid folder
+            for (const { name, path: folderPath } of validFolders) {
+                console_log_it(`Adding folder to zip: ${name}`, 'create_zip_folders');
+                if (onProgress) {
+                    onProgress({
+                        type: 'folder_start',
+                        folder: name,
+                        message: `Adding folder: ${name}`
+                    });
+                }
+                // Use our custom recursive function instead of archive.directory
+                addFolderRecursive(folderPath, name);
+            }
+            // Finalize the archive
+            console_log_it('Finalizing archive...', 'create_zip_folders');
+            archive.finalize();
+        }
+        catch (error) {
+            console_log_it(`Error in createZipFromFolders: ${error.message}`, 'create_zip_folders');
+            reject(error);
+        }
+    });
+}
+/**
+ * Calculate the total size of a folder (recursive)
+ * @param {string} folderPath - Path to the folder
+ * @returns {number} - Total size in bytes
+ */
+function calculateFolderSize(folderPath) {
+    let totalSize = 0;
+    try {
+        const items = fs.readdirSync(folderPath, { withFileTypes: true });
+        for (const item of items) {
+            const itemPath = path.join(folderPath, item.name);
+            if (item.isDirectory()) {
+                totalSize += calculateFolderSize(itemPath);
+            }
+            else if (item.isFile()) {
+                const stat = fs.statSync(itemPath);
+                totalSize += stat.size;
+            }
+        }
+    }
+    catch (error) {
+        console_log_it(`Error calculating folder size for ${folderPath}: ${error.message}`, 'calculate_folder_size');
+    }
+    return totalSize;
+}
+function sanitizeFolderName(folderName) {
+    // Remove file extension first
+    const nameWithoutExtension = folderName.replace(/\.[^/.]+$/, '');
+    // Then replace non-alphanumeric characters with underscores
+    return nameWithoutExtension.replace(/[^a-zA-Z0-9]/g, '_');
+}
+/**
+ * Create a zip file with training data from workflow steps
+ * @param {string} rootFolder - Root annotations folder
+ * @param {string} workflowId - Workflow ID
+ * @param {string[]} stepIds - Array of step IDs to include
+ * @param {Object} options - Additional options
+ * @returns {Promise<string>} - Path to the created zip file
+ */
+async function createTrainingDataZip(rootFolder, workflowId, stepIds, options = {}) {
+    const { includeMetadata = true, onProgress = null, outputFileName = null } = options;
+    try {
+        console.log(`Creating training data zip for workflow: ${workflowId}`, 'create_training_zip');
+        const sanitizedWorkflowId = sanitizeFolderName(workflowId);
+        const workflowFolder = path.join(rootFolder, sanitizedWorkflowId);
+        if (!fs.existsSync(workflowFolder)) {
+            throw new Error(`Workflow folder does not exist: ${workflowFolder}`);
+        }
+        // Build list of step folders
+        const stepFolders = stepIds.map(stepId => {
+            const sanitizedStepId = sanitizeFolderName(stepId);
+            return path.join(sanitizedWorkflowId, sanitizedStepId);
+        });
+        // Validate step folders exist
+        const existingStepFolders = stepFolders.filter(stepFolder => {
+            const fullPath = path.join(rootFolder, stepFolder);
+            return fs.existsSync(fullPath);
+        });
+        if (existingStepFolders.length === 0) {
+            throw new Error('No valid step folders found');
+        }
+        console_log_it(`Including ${existingStepFolders.length} step folders in zip`, 'create_training_zip');
+        // Create zip file name with timestamp
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+        const zipFileName = outputFileName || `training_data_${sanitizedWorkflowId}_${timestamp}`;
+        // Create metadata file in temp location
+        const tempMetadataPath = path.join(rootFolder, 'temp_metadata.json');
+        fs.writeFileSync(tempMetadataPath, JSON.stringify({
+            workflowId,
+            stepIds,
+            createdAt: new Date().toISOString(),
+            stepCount: existingStepFolders.length
+        }, null, 2));
+        // Add metadata file to the folders list
+        existingStepFolders.push('temp_metadata.json');
+        // Create the zip
+        const zipPath = await createZipFromFolders(rootFolder, existingStepFolders, zipFileName, {
+            onProgress: (progress) => {
+                if (onProgress) {
+                    onProgress({
+                        ...progress,
+                        workflowId,
+                        stepCount: existingStepFolders.length
+                    });
+                }
+            },
+            filter: (filePath, stat) => {
+                // Exclude temporary files and backups
+                const fileName = path.basename(filePath);
+                return !fileName.startsWith('temp_') &&
+                    !fileName.startsWith('.') &&
+                    !fileName.includes('_backup');
+            }
+        });
+        // Clean up temp metadata file
+        if (fs.existsSync(tempMetadataPath)) {
+            fs.unlinkSync(tempMetadataPath);
+        }
+        return zipPath;
+    }
+    catch (error) {
+        console_log_it(`Error creating training data zip: ${error.message}`, 'create_training_zip');
+        throw error;
+    }
+}
+/**
+ * Add metadata file to an existing zip
+ * @param {string} zipPath - Path to the zip file
+ * @param {Object} metadata - Metadata object to add
+ */
+async function addMetadataToZip(zipPath, metadata) {
+    return new Promise((resolve, reject) => {
+        try {
+            const tempMetadataPath = path.join(path.dirname(zipPath), 'temp_metadata.json');
+            fs.writeFileSync(tempMetadataPath, JSON.stringify(metadata, null, 2));
+            const output = fs.createWriteStream(zipPath + '.tmp');
+            const archive = archiver('zip');
+            // Extract existing zip and add metadata
+            const extract = require('extract-zip');
+            const tempDir = path.join(path.dirname(zipPath), 'temp_extract');
+            // This is simplified - you might want to use a proper zip library
+            // that supports adding files to existing archives
+            console_log_it('Adding metadata to zip (simplified implementation)', 'add_metadata_zip');
+            // Clean up temp files
+            if (fs.existsSync(tempMetadataPath)) {
+                fs.unlinkSync(tempMetadataPath);
+            }
+            resolve(undefined);
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}
+/**
+ * Given { classes: string[], parents: Record<string, string|null> },
+ * return the list of class names from root -> deepest child.
+ */
+function getRootToDeepestPath(data, depth = 10) {
+    const { classes = [], parents = {} } = data ?? {};
+    if (!Array.isArray(classes) || parents == null || typeof parents !== 'object') {
+        throw new TypeError('Expected shape: { classes: string[], parents: Record<string, string|null> }');
+    }
+    // Ensure every class has an entry in parents
+    for (const c of classes) {
+        if (!(c in parents)) {
+            throw new Error(`Missing parent mapping for "${c}"`);
+        }
+    }
+    // The deepest child is the class that is never listed as anyone's parent
+    const allParents = new Set(Object.values(parents).filter(Boolean));
+    const leaves = classes.filter(c => !allParents.has(c));
+    if (leaves.length !== 1) {
+        throw new Error(`Expected exactly one deepest child, found ${leaves.length}: [${leaves.join(', ')}]`);
+    }
+    // Walk backwards from the leaf up to the root (null), then reverse.
+    const path = [];
+    const seen = new Set();
+    let cur = leaves[0];
+    while (cur) {
+        if (seen.has(cur))
+            throw new Error('Cycle detected in parents map');
+        seen.add(cur);
+        path.push(cur);
+        cur = parents[cur] ?? null;
+    }
+    let res = path.reverse();
+    res = res.slice(0, depth); // limit to max depth
+    return res;
+}
+export function getFlowFrameSelectors(url, word) {
+    for (let key in flow_frame_selectors.selectors) {
+        if (key.startsWith(url)) {
+            return flow_frame_selectors.selectors[key]?.[word]?.positions[0];
+        }
+    }
+}
+export function hasFlowFrameKey(url, word) {
+    console.log(flow_frame_selectors);
+    for (let key in flow_frame_selectors.selectors) {
+        if (key.startsWith(url)) {
+            url = key;
+            break;
+        }
+    }
+    return !!flow_frame_selectors?.selectors?.[url]?.[word]?.positions?.length;
+}
+export function setFlowFrameText(url, dict) {
+    flow_frame_text[url] = dict;
+}
+export function getFlowFrameText(url) {
+    let result = {};
+    for (let url_regex of Object.keys(flow_frame_text)) {
+        console.log('testing', url_regex, url);
+        if (url_regex.startsWith(url)) {
+            result = flow_frame_text[url_regex];
+            break;
+        }
+    }
+    return result;
+}
+export function setFlowFrameSelector(location, selector) {
+    for (let key in flow_frame_text) {
+        if (key.startsWith(location)) {
+            location = key;
+            break;
+        }
+    }
+    flow_frame_selectors.selectors[location] = selector;
+}
+const flow_frame_selectors = {
+    selectors: {}
+};
+const flow_frame_text = {};
+export { get_jobs_path, findJobs, findVideoJobs, unique, set, get, setContext, getContext, refreshScreen, getModePositionKey, getModePosition, saveProjectFile, waitForQueuedRenders, readProjectFile, extractFileNameFromUrl, findExplorerWindowPosition, locateExtensionIcon, getDownloadsFolder, findSocialPorterVideos, ifYouDontFinish, getRootToDeepestPath, moveSocialPorterVideos, countFilesInDownloads, getFilesStartingWith, pressReturn, getFiles, getLastModifiedTimestampSync, findFileInDirectoryHasInWithAndEndingWith, deleteFileSync, downloadFiles, downloadFile, ensureDir, isThere, workflowOp, selectRandom, detectOrientation, getDetectOrientation, getMode, readJsonFiles, unzip, unzipFile, sanitizeFileName, alignLinesToWords, getVideoDuration, extractVersionNumber, waitFor, pasteText, getJobsContext, getItem, mouseClick, lerp, pause, getSortedFilesByUpdatedAt, createZipFromFolders, createTrainingDataZip, MIDJOURNEY_SELECTOR, input_bar, buildProgressBar, getLocalIp, applyTemplate, findFilesWithString, sanitizeFolderName };
+//# sourceMappingURL=utils.js.map