flow-frame-core 0.1.0

package/dist/stepWorkflowRoutes.js

@@ -0,0 +1,1007 @@
+import fs from 'fs';
+import path from 'path';
+import multer from 'multer';
+import { console_log_it } from './utils.js';
+import { localizeFirebaseStorageUrls } from "./services/localizeFirebaseMedia.js";
+// Configure multer for file uploads
+const createMulterConfig = (uploadDir) => {
+    // Ensure upload directory exists
+    if (!fs.existsSync(uploadDir)) {
+        fs.mkdirSync(uploadDir, { recursive: true });
+    }
+    const storage = multer.diskStorage({
+        destination: (req, file, cb) => {
+            cb(null, uploadDir);
+        },
+        filename: (req, file, cb) => {
+            // Generate unique filename with timestamp
+            const timestamp = Date.now();
+            const ext = path.extname(file.originalname);
+            const name = path.basename(file.originalname, ext);
+            const uniqueName = `${name}-${timestamp}${ext}`;
+            cb(null, uniqueName);
+        }
+    });
+    const fileFilter = (req, file, cb) => {
+        // Accept video, image, and automation files
+        const allowedTypes = [
+            'video/mp4', 'video/webm', 'video/ogg', 'video/mov', 'video/avi',
+            'image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/webp', 'image/svg+xml',
+            'application/json', 'text/plain'
+        ];
+        const isAutomationFile = file.originalname.endsWith('.automation') || file.originalname.endsWith('.json');
+        if (allowedTypes.includes(file.mimetype) || isAutomationFile) {
+            cb(null, true);
+        }
+        else {
+            cb(new Error('Invalid file type. Only video, image, and automation files are allowed.'), false);
+        }
+    };
+    return multer({
+        storage,
+        fileFilter,
+        limits: {
+            fileSize: 500 * 1024 * 1024 // 500MB limit
+        }
+    });
+};
+const buildFolderStructure = (dirPath, basePath = dirPath) => {
+    const items = [];
+    try {
+        const entries = fs.readdirSync(dirPath);
+        for (const entry of entries) {
+            const fullPath = path.join(dirPath, entry);
+            const stat = fs.statSync(fullPath);
+            const relativePath = path.relative(basePath, fullPath);
+            if (stat.isDirectory()) {
+                // Recursively build folder structure
+                const children = buildFolderStructure(fullPath, basePath);
+                items.push({
+                    id: `folder-${relativePath.replace(/[/\\]/g, '-')}`,
+                    name: entry,
+                    type: 'folder',
+                    children: children,
+                    icon: '📁',
+                    path: relativePath,
+                    lastModified: stat.mtime,
+                    source: 'local'
+                });
+            }
+            else if (stat.isFile() && (entry.endsWith('.automation') || entry.endsWith('.json'))) {
+                // Add config files
+                const isWorkflow = entry.endsWith('.automation') || entry.endsWith('.json');
+                items.push({
+                    id: `file-${relativePath.replace(/[/\\]/g, '-')}`,
+                    name: entry,
+                    type: 'file',
+                    icon: isWorkflow ? '🔄' : '📄',
+                    path: relativePath,
+                    lastModified: stat.mtime,
+                    size: stat.size,
+                    isConfigFile: !isWorkflow,
+                    isWorkflowFile: isWorkflow,
+                    source: 'local'
+                });
+            }
+        }
+    }
+    catch (error) {
+        console.error(`Error reading directory ${dirPath}:`, error);
+    }
+    // Sort folders first, then files, both alphabetically
+    return items.sort((a, b) => {
+        if (a.type !== b.type) {
+            return a.type === 'folder' ? -1 : 1;
+        }
+        return a.name.localeCompare(b.name);
+    });
+};
+export function registerStepWorkflowRoutes(app, getWorkflowsDir, getMediaDir, getUIMapDir, getPromptLibDir) {
+    const workflowsDir = getWorkflowsDir();
+    const mediaDir = getMediaDir();
+    const uiMapDir = getUIMapDir();
+    const promptLibDir = getPromptLibDir ? getPromptLibDir() : null;
+    if (!workflowsDir || !mediaDir) {
+        console_log_it('Error: Workflows or Media directory is not defined');
+        return;
+    }
+    // Ensure directories exist
+    if (!fs.existsSync(workflowsDir)) {
+        fs.mkdirSync(workflowsDir, { recursive: true });
+    }
+    if (!fs.existsSync(mediaDir)) {
+        fs.mkdirSync(mediaDir, { recursive: true });
+    }
+    if (promptLibDir && !fs.existsSync(promptLibDir)) {
+        fs.mkdirSync(promptLibDir, { recursive: true });
+    }
+    const upload = createMulterConfig(mediaDir);
+    console_log_it('Registering Step Workflow routes...');
+    // ═══════════════════════════════════════════════════════════════════════
+    // WORKFLOW MANAGEMENT ENDPOINTS
+    // ═══════════════════════════════════════════════════════════════════════
+    // Get all workflows
+    app.get('/api/workflows', (req, res) => {
+        try {
+            const files = fs.readdirSync(workflowsDir, { recursive: true, withFileTypes: true })
+                .filter(file => file.isFile() && (file.name.endsWith('.automation') || file.name.endsWith('.json')))
+                .map(file => {
+                const filePath = path.join(file.parentPath, file.name);
+                const stats = fs.statSync(filePath);
+                const relativePath = path.relative(workflowsDir, filePath).replace(/\//g, '//');
+                let workflow = {};
+                try {
+                    const content = fs.readFileSync(filePath, 'utf8');
+                    workflow = JSON.parse(content);
+                }
+                catch (e) {
+                    console_log_it(`Error parsing workflow ${file.name}:`, e.message);
+                }
+                return {
+                    id: relativePath,
+                    filename: file.name,
+                    name: workflow.name || path.basename(file.name, path.extname(file.name)),
+                    description: workflow.description || '',
+                    stepCount: workflow.steps ? workflow.steps.length : 0,
+                    mediaUrl: workflow.url || null,
+                    createdAt: stats.birthtime,
+                    modifiedAt: stats.mtime,
+                    size: stats.size,
+                    relativePath: relativePath
+                };
+            })
+                .sort((a, b) => b.modifiedAt - a.modifiedAt);
+            const folderStructure = buildFolderStructure(workflowsDir, workflowsDir);
+            res.json({ success: true, workflows: files, folderStructure });
+        }
+        catch (error) {
+            console_log_it('Error listing workflows:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Get specific workflow
+    app.get('/api/workflows/:id(*)', (req, res) => {
+        try {
+            const { id } = req.params;
+            let filename = id;
+            // Try to find the file with or without extension
+            const filePath = path.join(workflowsDir, filename);
+            const automationPath = path.join(workflowsDir, `${filename}.automation`);
+            const jsonPath = path.join(workflowsDir, `${filename}.json`);
+            let targetPath = null;
+            // Check exact match first (if id has extension)
+            if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
+                targetPath = filePath;
+            }
+            // Check .automation
+            else if (fs.existsSync(automationPath)) {
+                targetPath = automationPath;
+            }
+            // Check .json
+            else if (fs.existsSync(jsonPath)) {
+                targetPath = jsonPath;
+            }
+            if (!targetPath) {
+                return res.status(404).json({ success: false, error: 'Workflow not found' });
+            }
+            const content = fs.readFileSync(targetPath, 'utf8');
+            const workflow = JSON.parse(content);
+            res.json({ success: true, workflow });
+        }
+        catch (error) {
+            console_log_it('Error reading workflow:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Create or update workflow
+    app.post('/api/workflows/:id(*)', async (req, res) => {
+        try {
+            const { id } = req.params;
+            const workflow = req.body;
+            // Validate workflow structure
+            if (!workflow.steps || !Array.isArray(workflow.steps)) {
+                return res.status(400).json({
+                    success: false,
+                    error: 'Invalid workflow: steps array is required'
+                });
+            }
+            let filename = id;
+            if (!filename.endsWith('.automation') && !filename.endsWith('.json')) {
+                filename += '.automation';
+            }
+            const filePath = path.join(workflowsDir, filename);
+            // Ensure directory exists
+            const dir = path.dirname(filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            // Add metadata
+            const workflowWithMeta = {
+                ...workflow,
+                id,
+                lastModified: new Date().toISOString(),
+                version: workflow.version || '1.0.0'
+            };
+            try {
+                // Get the relative file path of filename
+                let relativeFilePath = path.relative(workflowsDir, filePath).replace(/\\/g, '/');
+                const result = await localizeFirebaseStorageUrls({
+                    inputJson: workflowWithMeta,
+                    baseFolder: mediaDir,
+                    targetFolder: relativeFilePath,
+                    extension: 'jpg',
+                    apiPrefix: '/api/media'
+                });
+                console.log('Localized Firebase Storage URLs:', result);
+                fs.writeFileSync(filePath, JSON.stringify(result.updated, null, 2));
+            }
+            catch (e) {
+                console.error('Error localizing Firebase Storage URLs:', e);
+            }
+            res.json({ success: true, message: 'Workflow saved successfully' });
+        }
+        catch (error) {
+            console_log_it('Error saving workflow:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Delete workflow
+    app.delete('/api/workflows/:id(*)', (req, res) => {
+        try {
+            const { id } = req.params;
+            let filename = id;
+            // Try to find the file with or without extension
+            const filePath = path.join(workflowsDir, filename);
+            const automationPath = path.join(workflowsDir, `${filename}.automation`);
+            const jsonPath = path.join(workflowsDir, `${filename}.json`);
+            let deleted = false;
+            // Check exact match first (if id has extension)
+            if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
+                fs.unlinkSync(filePath);
+                deleted = true;
+            }
+            // Check .automation
+            else if (fs.existsSync(automationPath)) {
+                fs.unlinkSync(automationPath);
+                deleted = true;
+            }
+            // Check .json
+            else if (fs.existsSync(jsonPath)) {
+                fs.unlinkSync(jsonPath);
+                deleted = true;
+            }
+            if (!deleted) {
+                return res.status(404).json({ success: false, error: 'Workflow not found' });
+            }
+            res.json({ success: true, message: 'Workflow deleted successfully' });
+        }
+        catch (error) {
+            console_log_it('Error deleting workflow:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Duplicate workflow
+    app.post('/api/workflows/:id(*)/duplicate', (req, res) => {
+        try {
+            const { id } = req.params;
+            const { newName } = req.body;
+            let sourceFilename = id;
+            if (!sourceFilename.endsWith('.automation') && !sourceFilename.endsWith('.json')) {
+                sourceFilename += '.automation';
+            }
+            // Try to find source
+            let sourcePath = path.join(workflowsDir, sourceFilename);
+            if (!fs.existsSync(sourcePath)) {
+                // Try .json if .automation failed
+                if (sourceFilename.endsWith('.automation')) {
+                    sourcePath = path.join(workflowsDir, sourceFilename.replace('.automation', '.json'));
+                }
+            }
+            if (!fs.existsSync(sourcePath)) {
+                // Try exact match if extension was already there
+                sourcePath = path.join(workflowsDir, id);
+            }
+            if (!fs.existsSync(sourcePath)) {
+                return res.status(404).json({ success: false, error: 'Source workflow not found' });
+            }
+            const content = fs.readFileSync(sourcePath, 'utf8');
+            const workflow = JSON.parse(content);
+            const newId = newName || `${id}-copy-${Date.now()}`;
+            let newFilename = newId;
+            if (!newFilename.endsWith('.automation') && !newFilename.endsWith('.json')) {
+                newFilename += '.automation';
+            }
+            const newPath = path.join(workflowsDir, newFilename);
+            // Ensure directory exists for new file
+            const dir = path.dirname(newPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            const duplicatedWorkflow = {
+                ...workflow,
+                id: newId,
+                name: `${workflow.name || id} (Copy)`,
+                lastModified: new Date().toISOString()
+            };
+            fs.writeFileSync(newPath, JSON.stringify(duplicatedWorkflow, null, 2));
+            res.json({ success: true, id: newId, message: 'Workflow duplicated successfully' });
+        }
+        catch (error) {
+            console_log_it('Error duplicating workflow:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // ═══════════════════════════════════════════════════════════════════════
+    // UI MAP ENDPOINTS
+    // ═══════════════════════════════════════════════════════════════════════
+    // Get all UI Maps
+    app.get('/api/ui-maps', (req, res) => {
+        try {
+            const files = fs.readdirSync(uiMapDir, { recursive: true, withFileTypes: true })
+                .filter(file => file.isFile() && file.name.endsWith('.ui_map'))
+                .map(file => {
+                const filePath = path.join(file.parentPath, file.name);
+                const stats = fs.statSync(filePath);
+                const relativePath = path.relative(uiMapDir, filePath).replace(/\\/g, '/');
+                let content = null;
+                try {
+                    content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+                }
+                catch (e) {
+                    console_log_it(`Error parsing UI Map ${file.name}:`, e.message);
+                }
+                return {
+                    id: relativePath,
+                    filename: file.name,
+                    name: content?.name || path.basename(file.name, '.ui_map'),
+                    lastModified: stats.mtime,
+                    size: stats.size,
+                    relativePath: relativePath
+                };
+            })
+                .sort((a, b) => b.lastModified - a.lastModified);
+            res.json({ success: true, uiMaps: files });
+        }
+        catch (error) {
+            console_log_it('Error listing UI Maps:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Get specific UI Map
+    app.get('/api/ui-maps/:id(*)', (req, res) => {
+        try {
+            const { id } = req.params;
+            let filename = id;
+            if (!filename.endsWith('.ui_map')) {
+                filename += '.ui_map';
+            }
+            const filePath = path.join(uiMapDir, filename);
+            if (!fs.existsSync(filePath)) {
+                return res.status(404).json({ success: false, error: 'UI Map not found' });
+            }
+            const content = fs.readFileSync(filePath, 'utf8');
+            const uiMap = JSON.parse(content);
+            res.json({ success: true, uiMap });
+        }
+        catch (error) {
+            console_log_it('Error reading UI Map:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Save UI Map
+    app.post('/api/ui-maps/:id(*)', (req, res) => {
+        try {
+            const { id } = req.params;
+            const uiMapData = req.body;
+            let filename = id;
+            if (!filename.endsWith('.ui_map')) {
+                filename += '.ui_map';
+            }
+            const filePath = path.join(uiMapDir, filename);
+            // Ensure directory exists
+            const dir = path.dirname(filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(filePath, JSON.stringify(uiMapData, null, 2));
+            res.json({ success: true, message: 'UI Map saved successfully' });
+        }
+        catch (error) {
+            console_log_it('Error saving UI Map:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Delete UI Map
+    app.delete('/api/ui-maps/:id(*)', (req, res) => {
+        try {
+            const { id } = req.params;
+            let filename = id;
+            if (!filename.endsWith('.ui_map')) {
+                filename += '.ui_map';
+            }
+            const filePath = path.join(uiMapDir, filename);
+            if (!fs.existsSync(filePath)) {
+                return res.status(404).json({ success: false, error: 'UI Map not found' });
+            }
+            fs.unlinkSync(filePath);
+            res.json({ success: true, message: 'UI Map deleted successfully' });
+        }
+        catch (error) {
+            console_log_it('Error deleting UI Map:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // ═══════════════════════════════════════════════════════════════════════
+    // PROMPT LIB ENDPOINTS
+    // ═══════════════════════════════════════════════════════════════════════
+    // Get all Prompt Libs
+    app.get('/api/prompt-libs', (req, res) => {
+        if (!promptLibDir)
+            return res.json({ success: true, promptLibs: [] });
+        try {
+            const files = fs.readdirSync(promptLibDir, { recursive: true, withFileTypes: true })
+                .filter(file => file.isFile() && file.name.endsWith('.prompt_lib'))
+                .map(file => {
+                const filePath = path.join(file.parentPath, file.name);
+                const stats = fs.statSync(filePath);
+                const relativePath = path.relative(promptLibDir, filePath).replace(/\\/g, '/');
+                let content = null;
+                try {
+                    content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+                }
+                catch (e) {
+                    console_log_it(`Error parsing Prompt Lib ${file.name}:`, e.message);
+                }
+                return {
+                    id: relativePath,
+                    filename: file.name,
+                    name: content?.name || path.basename(file.name, '.prompt_lib'),
+                    lastModified: stats.mtime,
+                    size: stats.size,
+                    relativePath: relativePath
+                };
+            })
+                .sort((a, b) => b.lastModified - a.lastModified);
+            res.json({ success: true, promptLibs: files });
+        }
+        catch (error) {
+            console_log_it('Error listing Prompt Libs:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Get specific Prompt Lib
+    app.get('/api/prompt-libs/:id(*)', (req, res) => {
+        if (!promptLibDir)
+            return res.status(404).json({ success: false, error: 'Prompt Lib directory not configured' });
+        try {
+            const { id } = req.params;
+            let filename = id;
+            if (!filename.endsWith('.prompt_lib')) {
+                filename += '.prompt_lib';
+            }
+            const filePath = path.join(promptLibDir, filename);
+            if (!fs.existsSync(filePath)) {
+                return res.status(404).json({ success: false, error: 'Prompt Lib not found' });
+            }
+            const content = fs.readFileSync(filePath, 'utf8');
+            const promptLib = JSON.parse(content);
+            res.json({ success: true, promptLib });
+        }
+        catch (error) {
+            console_log_it('Error reading Prompt Lib:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Save Prompt Lib
+    app.post('/api/prompt-libs/:id(*)', (req, res) => {
+        if (!promptLibDir)
+            return res.status(500).json({ success: false, error: 'Prompt Lib directory not configured' });
+        try {
+            const { id } = req.params;
+            const promptLibData = req.body;
+            let filename = id;
+            if (!filename.endsWith('.prompt_lib')) {
+                filename += '.prompt_lib';
+            }
+            const filePath = path.join(promptLibDir, filename);
+            // Ensure directory exists
+            const dir = path.dirname(filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(filePath, JSON.stringify(promptLibData, null, 2));
+            res.json({ success: true, message: 'Prompt Lib saved successfully' });
+        }
+        catch (error) {
+            console_log_it('Error saving Prompt Lib:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Delete Prompt Lib
+    app.delete('/api/prompt-libs/:id(*)', (req, res) => {
+        if (!promptLibDir)
+            return res.status(500).json({ success: false, error: 'Prompt Lib directory not configured' });
+        try {
+            const { id } = req.params;
+            let filename = id;
+            if (!filename.endsWith('.prompt_lib')) {
+                filename += '.prompt_lib';
+            }
+            const filePath = path.join(promptLibDir, filename);
+            if (!fs.existsSync(filePath)) {
+                return res.status(404).json({ success: false, error: 'Prompt Lib not found' });
+            }
+            fs.unlinkSync(filePath);
+            res.json({ success: true, message: 'Prompt Lib deleted successfully' });
+        }
+        catch (error) {
+            console_log_it('Error deleting Prompt Lib:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // ═══════════════════════════════════════════════════════════════════════
+    // MEDIA MANAGEMENT ENDPOINTS
+    // ═══════════════════════════════════════════════════════════════════════
+    // Upload media file
+    app.post('/api/media/upload', (req, res) => {
+        console_log_it('=== MEDIA UPLOAD REQUEST START ===');
+        console_log_it('Content-Type:', req.headers['content-type']);
+        console_log_it('Content-Length:', req.headers['content-length']);
+        console_log_it('Media directory:', mediaDir);
+        console_log_it('Media directory exists:', fs.existsSync(mediaDir));
+        const uploadMiddleware = upload.single('media');
+        uploadMiddleware(req, res, (err) => {
+            if (err) {
+                console_log_it('=== MULTER ERROR ===');
+                console_log_it('Error type:', err.constructor.name);
+                console_log_it('Error message:', err.message);
+                console_log_it('Error code:', err.code);
+                if (err instanceof multer.MulterError) {
+                    if (err.code === 'LIMIT_FILE_SIZE') {
+                        return res.status(400).json({
+                            success: false,
+                            error: 'File too large. Maximum size is 500MB.'
+                        });
+                    }
+                    else if (err.code === 'LIMIT_UNEXPECTED_FILE') {
+                        return res.status(400).json({
+                            success: false,
+                            error: 'Unexpected field name. Use "media" as the field name.'
+                        });
+                    }
+                }
+                return res.status(500).json({
+                    success: false,
+                    error: err.message,
+                    code: err.code || 'UNKNOWN_ERROR'
+                });
+            }
+            try {
+                console_log_it('=== MULTER SUCCESS ===');
+                console_log_it('req.file:', req.file);
+                if (!req.file) {
+                    console_log_it('No file in request');
+                    return res.status(400).json({ success: false, error: 'No file uploaded' });
+                }
+                const ext = path.extname(req.file.filename).toLowerCase();
+                const isVideo = ['.mp4', '.webm', '.ogg', '.mov', '.avi'].includes(ext);
+                const fileInfo = {
+                    id: `${isVideo ? 'vid' : 'img'}_${req.file.filename}`, // Add ID field
+                    filename: req.file.filename,
+                    originalName: req.file.originalname, // Keep this for MediaLibraryContext
+                    mimetype: req.file.mimetype,
+                    size: req.file.size,
+                    url: `/api/media/${req.file.filename}`,
+                    uploadedAt: new Date().toISOString(),
+                    thumbnail: null // Add thumbnail field
+                };
+                console_log_it('=== UPLOAD SUCCESS ===');
+                console_log_it('File info:', fileInfo);
+                res.json({ success: true, file: fileInfo });
+            }
+            catch (processError) {
+                console_log_it('=== PROCESSING ERROR ===');
+                console_log_it('Processing error:', processError);
+                res.status(500).json({
+                    success: false,
+                    error: processError.message,
+                    type: 'PROCESSING_ERROR'
+                });
+            }
+        });
+    });
+    // Get media file
+    app.get('/api/media/:filename(*)', (req, res) => {
+        try {
+            const { filename } = req.params;
+            const filePath = path.join(mediaDir, filename);
+            if (!fs.existsSync(filePath)) {
+                return res.status(404).json({ success: false, error: 'Media file not found' });
+            }
+            // Set appropriate headers
+            const ext = path.extname(filename).toLowerCase();
+            const mimeTypes = {
+                '.mp4': 'video/mp4',
+                '.webm': 'video/webm',
+                '.ogg': 'video/ogg',
+                '.mov': 'video/quicktime',
+                '.avi': 'video/x-msvideo',
+                '.jpg': 'image/jpeg',
+                '.jpeg': 'image/jpeg',
+                '.png': 'image/png',
+                '.gif': 'image/gif',
+                '.webp': 'image/webp',
+                '.svg': 'image/svg+xml'
+            };
+            const mimeType = mimeTypes[ext] || 'application/octet-stream';
+            res.setHeader('Content-Type', mimeType);
+            // Enable range requests for video
+            if (mimeType.startsWith('video/')) {
+                const stat = fs.statSync(filePath);
+                const fileSize = stat.size;
+                const range = req.headers.range;
+                if (range) {
+                    const parts = range.replace(/bytes=/, "").split("-");
+                    const start = parseInt(parts[0], 10);
+                    const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;
+                    const chunksize = (end - start) + 1;
+                    res.status(206);
+                    res.setHeader('Content-Range', `bytes ${start}-${end}/${fileSize}`);
+                    res.setHeader('Accept-Ranges', 'bytes');
+                    res.setHeader('Content-Length', chunksize);
+                    const stream = fs.createReadStream(filePath, { start, end });
+                    stream.pipe(res);
+                }
+                else {
+                    res.setHeader('Content-Length', fileSize);
+                    fs.createReadStream(filePath).pipe(res);
+                }
+            }
+            else {
+                res.sendFile(filePath);
+            }
+        }
+        catch (error) {
+            console_log_it('Error serving media:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // List media files - UPDATE this endpoint to return the expected format
+    app.get('/api/media', (req, res) => {
+        try {
+            const files = fs.readdirSync(mediaDir)
+                .filter(file => {
+                const ext = path.extname(file).toLowerCase();
+                return ['.mp4', '.webm', '.ogg', '.mov', '.avi', '.jpg', '.jpeg', '.png', '.gif', '.webp', '.svg'].includes(ext);
+            })
+                .map(file => {
+                const filePath = path.join(mediaDir, file);
+                const stats = fs.statSync(filePath);
+                const ext = path.extname(file).toLowerCase();
+                const isVideo = ['.mp4', '.webm', '.ogg', '.mov', '.avi'].includes(ext);
+                return {
+                    id: `${isVideo ? 'vid' : 'img'}_${file}`, // Add ID field that MediaLibraryContext expects
+                    filename: file,
+                    url: `/api/media/${file}`,
+                    type: isVideo ? 'video' : 'image',
+                    size: stats.size,
+                    uploadedAt: stats.birthtime.toISOString(), // Convert to ISO string
+                    thumbnail: null // Add thumbnail field
+                };
+            })
+                .sort((a, b) => new Date(b.uploadedAt) - new Date(a.uploadedAt));
+            // Return in the format expected by MediaLibraryContext
+            res.json({
+                success: true,
+                media: files, // Changed from 'files' to 'media'
+                count: files.length
+            });
+        }
+        catch (error) {
+            console_log_it('Error listing media:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Delete media file
+    app.delete('/api/media/:filename(*)', (req, res) => {
+        try {
+            const { filename } = req.params;
+            const filePath = path.join(mediaDir, filename);
+            if (!fs.existsSync(filePath)) {
+                return res.status(404).json({ success: false, error: 'Media file not found' });
+            }
+            fs.unlinkSync(filePath);
+            res.json({ success: true, message: 'Media file deleted successfully' });
+        }
+        catch (error) {
+            console_log_it('Error deleting media:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Add a new endpoint to delete media by ID (MediaLibraryContext expects this)
+    app.delete('/api/media/:id(*)', (req, res) => {
+        try {
+            const { id } = req.params;
+            // Extract filename from ID (remove img_ or vid_ prefix)
+            const filename = id.replace(/^(img_|vid_)/, '');
+            const filePath = path.join(mediaDir, filename);
+            if (!fs.existsSync(filePath)) {
+                return res.status(404).json({ success: false, error: 'Media file not found' });
+            }
+            fs.unlinkSync(filePath);
+            res.json({ success: true, message: 'Media file deleted successfully' });
+        }
+        catch (error) {
+            console_log_it('Error deleting media:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Add endpoint to get media info by ID
+    app.get('/api/media/info/:id(*)', (req, res) => {
+        try {
+            const { id } = req.params;
+            // Extract filename from ID
+            const filename = id.replace(/^(img_|vid_)/, '');
+            const filePath = path.join(mediaDir, filename);
+            if (!fs.existsSync(filePath)) {
+                return res.status(404).json({ success: false, error: 'Media file not found' });
+            }
+            const stats = fs.statSync(filePath);
+            const ext = path.extname(filename).toLowerCase();
+            const isVideo = ['.mp4', '.webm', '.ogg', '.mov', '.avi'].includes(ext);
+            const mediaInfo = {
+                id,
+                filename,
+                url: `/api/media/${filename}`,
+                type: isVideo ? 'video' : 'image',
+                size: stats.size,
+                uploadedAt: stats.birthtime.toISOString(),
+                thumbnail: null
+            };
+            res.json({ success: true, media: mediaInfo });
+        }
+        catch (error) {
+            console_log_it('Error getting media info:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Keep the existing /api/media/:filename endpoint for serving files (don't change this)
+    // This serves the actual file content and is different from the info endpoint above
+    // ═══════════════════════════════════════════════════════════════════════
+    // WORKFLOW EXECUTION ENDPOINTS
+    // ═══════════════════════════════════════════════════════════════════════
+    // Execute workflow
+    app.post('/api/workflows/:id(*)/execute', async (req, res) => {
+        try {
+            const { id } = req.params;
+            const { startStep = 0, endStep, dryRun = false } = req.body;
+            let filename = id;
+            if (!filename.endsWith('.automation') && !filename.endsWith('.json')) {
+                filename += '.automation';
+            }
+            let filePath = path.join(workflowsDir, filename);
+            if (!fs.existsSync(filePath)) {
+                // Try .json
+                if (filename.endsWith('.automation')) {
+                    filePath = path.join(workflowsDir, filename.replace('.automation', '.json'));
+                }
+            }
+            if (!fs.existsSync(filePath)) {
+                // Try exact match
+                filePath = path.join(workflowsDir, id);
+            }
+            if (!fs.existsSync(filePath)) {
+                return res.status(404).json({ success: false, error: 'Workflow not found' });
+            }
+            const content = fs.readFileSync(filePath, 'utf8');
+            const workflow = JSON.parse(content);
+            if (!workflow.steps || !Array.isArray(workflow.steps)) {
+                return res.status(400).json({ success: false, error: 'Invalid workflow format' });
+            }
+            const steps = workflow.steps.slice(startStep, endStep);
+            const results = [];
+            console_log_it(`Executing workflow ${id} - Steps ${startStep} to ${endStep || workflow.steps.length - 1} (Dry run: ${dryRun})`);
+            for (let i = 0; i < steps.length; i++) {
+                const step = steps[i];
+                const stepIndex = startStep + i;
+                console_log_it(`Executing step ${stepIndex + 1}: ${step.type}`);
+                const stepResult = {
+                    stepIndex,
+                    type: step.type,
+                    description: step.description,
+                    startTime: Date.now(),
+                    success: false,
+                    error: null,
+                    data: null
+                };
+                try {
+                    if (!dryRun) {
+                        // Execute the actual step here
+                        // This would integrate with your existing automation system
+                        stepResult.data = await executeWorkflowStep(step);
+                    }
+                    else {
+                        stepResult.data = { message: 'Dry run - step not executed' };
+                    }
+                    stepResult.success = true;
+                }
+                catch (error) {
+                    stepResult.error = error.message;
+                    console_log_it(`Step ${stepIndex + 1} failed:`, error.message);
+                    if (!req.body.continueOnError) {
+                        results.push({ ...stepResult, endTime: Date.now() });
+                        break;
+                    }
+                }
+                stepResult.endTime = Date.now();
+                results.push(stepResult);
+                // Add delay between steps if specified
+                if (step.delay && !dryRun) {
+                    await new Promise(resolve => setTimeout(resolve, step.delay));
+                }
+            }
+            res.json({
+                success: true,
+                message: 'Workflow execution completed',
+                results,
+                totalSteps: steps.length,
+                successfulSteps: results.filter(r => r.success).length
+            });
+        }
+        catch (error) {
+            console_log_it('Error executing workflow:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Validate workflow
+    app.post('/api/workflows/:id(*)/validate', (req, res) => {
+        try {
+            const { id } = req.params;
+            let filename = id;
+            if (!filename.endsWith('.automation') && !filename.endsWith('.json')) {
+                filename += '.automation';
+            }
+            let filePath = path.join(workflowsDir, filename);
+            if (!fs.existsSync(filePath)) {
+                // Try .json
+                if (filename.endsWith('.automation')) {
+                    filePath = path.join(workflowsDir, filename.replace('.automation', '.json'));
+                }
+            }
+            if (!fs.existsSync(filePath)) {
+                // Try exact match
+                filePath = path.join(workflowsDir, id);
+            }
+            if (!fs.existsSync(filePath)) {
+                return res.status(404).json({ success: false, error: 'Workflow not found' });
+            }
+            const content = fs.readFileSync(filePath, 'utf8');
+            const workflow = JSON.parse(content);
+            const validation = validateWorkflow(workflow);
+            res.json({ success: true, validation });
+        }
+        catch (error) {
+            console_log_it('Error validating workflow:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // Import workflow from file
+    app.post('/api/workflows/import', upload.single('workflow'), (req, res) => {
+        try {
+            if (!req.file) {
+                return res.status(400).json({ success: false, error: 'No workflow file uploaded' });
+            }
+            const content = fs.readFileSync(req.file.path, 'utf8');
+            const workflow = JSON.parse(content);
+            // Generate unique ID if not provided
+            const id = workflow.id || `imported-${Date.now()}`;
+            const targetPath = path.join(workflowsDir, `${id}.automation`);
+            // Add import metadata
+            const importedWorkflow = {
+                ...workflow,
+                id,
+                imported: true,
+                importedAt: new Date().toISOString(),
+                originalFilename: req.file.originalname
+            };
+            fs.writeFileSync(targetPath, JSON.stringify(importedWorkflow, null, 2));
+            // Clean up uploaded file
+            fs.unlinkSync(req.file.path);
+            res.json({
+                success: true,
+                message: 'Workflow imported successfully',
+                id,
+                stepCount: workflow.steps ? workflow.steps.length : 0
+            });
+        }
+        catch (error) {
+            console_log_it('Error importing workflow:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    console_log_it('Step Workflow routes registered successfully');
+}
+// Helper function to execute individual workflow steps
+async function executeWorkflowStep(step) {
+    // This function would integrate with your existing automation system
+    // For now, it's a placeholder that simulates step execution
+    switch (step.type) {
+        case 'pause':
+            const duration = step.params?.duration || 1000;
+            await new Promise(resolve => setTimeout(resolve, duration));
+            return { message: `Paused for ${duration}ms` };
+        case 'capture':
+            // Integrate with your screenshot functionality
+            return { message: 'Screenshot captured', imagePath: '/tmp/screenshot.png' };
+        case 'ocr':
+            // Integrate with your OCR functionality
+            return { message: 'OCR analysis completed', boxes: [] };
+        case 'move-mouse':
+            // Integrate with robotjs mouse movement
+            return { message: 'Mouse moved', position: { x: 0, y: 0 } };
+        case 'click':
+            // Integrate with robotjs click
+            return { message: 'Mouse clicked' };
+        case 'type':
+            // Integrate with robotjs typing
+            const text = step.params?.keys || '';
+            return { message: `Typed: ${text}` };
+        case 'automation':
+            // Execute another automation workflow
+            const automationId = step.params?.automationId;
+            if (!automationId) {
+                throw new Error('Automation step requires automationId parameter');
+            }
+            // This would need to be implemented to actually execute the referenced automation
+            return { message: `Automation "${automationId}" executed` };
+        default:
+            throw new Error(`Unknown step type: ${step.type}`);
+    }
+}
+// Helper function to validate workflow structure
+function validateWorkflow(workflow) {
+    const errors = [];
+    const warnings = [];
+    if (!workflow.steps || !Array.isArray(workflow.steps)) {
+        errors.push('Workflow must have a steps array');
+        return { valid: false, errors, warnings };
+    }
+    if (workflow.steps.length === 0) {
+        warnings.push('Workflow has no steps');
+    }
+    workflow.steps.forEach((step, index) => {
+        if (!step.type) {
+            errors.push(`Step ${index + 1}: Missing step type`);
+        }
+        // Validate step-specific requirements
+        switch (step.type) {
+            case 'ocr':
+                if (!step.params?.region) {
+                    warnings.push(`Step ${index + 1}: OCR step without region parameter`);
+                }
+                break;
+            case 'move-mouse':
+                if (!step.params?.filter && !step.params?.relative && !step.params?.absolute) {
+                    errors.push(`Step ${index + 1}: Move mouse step needs filter, relative, or absolute parameters`);
+                }
+                break;
+            case 'type':
+                if (!step.params?.keys) {
+                    errors.push(`Step ${index + 1}: Type step missing keys parameter`);
+                }
+                break;
+            case 'automation':
+                if (!step.params?.automationId) {
+                    errors.push(`Step ${index + 1}: Automation step missing automationId parameter`);
+                }
+                break;
+        }
+    });
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+        stepCount: workflow.steps.length
+    };
+}
+//# sourceMappingURL=stepWorkflowRoutes.js.map