Upload 5 files

Dockerfile

@@ -1,7 +1,7 @@
 FROM node:18-slim
 
 RUN apt-get update && \
-    apt-get install -y ffmpeg && \
+    apt-get install -y ffmpeg imagemagick && \
     rm -rf /var/lib/apt/lists/*
 
 WORKDIR /usr/src/app

README.md

@@ -1,6 +1,6 @@
 ---
-title: Async Command Runner
-emoji: 🏃
+title: Hybrid Command Runner
+emoji: 🚀
 colorFrom: indigo
 colorTo: blue
 sdk: docker
@@ -9,62 +9,45 @@ pinned: false
 
 # API для выполнения команд
 
-Это API позволяет удаленно выполнять консольные команды. Поддерживается два режима:
-
-1.  **Потоковый (Stream)**: Быстрая обработка "на лету" для простых команд.
-2.  **Асинхронные задачи (Tasks)**: Для длительных операций, с возможностью отслеживания прогресса.
+Это API позволяет удаленно выполнять консольные команды. Поддерживается два режима, но основной — это **умный стриминг**.
 
 ---
 
-## Режим 1: Потоковая обработка
+## Режим 1: "Умный" стриминг (рекомендуемый)
 
-Идеально для быстрых команд. Файл передается в `stdin` команды, а результат из `stdout` возвращается клиенту. Файлы не сохраняются на диске.
+Этот эндпоинт — ваш основной инструмент. Он автоматически определяет лучший способ выполнения команды.
 
 **Эндпоинт:** `POST /api/run/stream`
 
-**Пример `curl`:**
+### Использование с FFmpeg (Надежный режим)
+
+Если вы вызываете `ffmpeg`, API автоматически сохранит ваш файл на сервере, выполнит команду и вернет вам готовый результат. **Запрос будет длиться ровно столько, сколько идет конвертация.**
+
+**Пример `curl` для конвертации видео:**
 ```bash
+# Эта команда теперь будет работать через /api/run/stream
 curl -X POST 'https://<your-space-url>/api/run/stream' \
--F 'file=@/path/to/your/image.jpg' \
--F 'command=magick' \
--F 'args=["convert", "-", "-grayscale", "average", "jpg:-"]' \
---output grayscale_image.jpg
-
-Режим 2: Асинхронные задачи
-Используйте, когда команде нужно работать с файлами на диске или когда результат нужно сохранить.
-Шаг 1: Создание задачи
-Эндпоинт: POST /api/task/create
-Пример curl:
-curl -X POST 'https://<your-space-url>/api/task/create' \
 -F 'command=ffmpeg' \
 -F 'args=["-i", "{INPUT_FILE}", "-vcodec", "libx264", "-acodec", "aac", "{OUTPUT_FILE}"]' \
 -F 'file=@"/path/to/your/video.mov"' \
--F 'output_filename=converted.mp4'
+--output "converted_video.mp4"
 
-Ответ сервера (статус 202 Accepted):
-{
-    "message": "Task accepted.",
-    "taskId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
-    "status_url": "/api/task/status/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
-}
-
-Шаг 2: Проверка статуса задачи
-Эндпоинт: GET /api/task/status/:taskId
-Отправляйте GET-запросы на status_url, чтобы отслеживать выполнение.
-Пример ответа (завершено):
-{
-    "id": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
-    "status": "completed",
-    "elapsedTimeSeconds": 60,
-    "result": {
-        "download_url": "/api/download/yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy-converted.mp4"
-    }
-}
-
-Шаг 3: Скачивание результата
-Когда задача получает статус completed, используйте download_url для скачивания файла.
-Эндпоинт: GET /api/download/:fileId
-curl 'https://<your-space-url>/api/download/yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy-converted.mp4' \
---output "final_video.mp4"
+Использование с другими командами (Режим реального стриминга)
+Для команд вроде magick (ImageMagick) API работает в режиме реального времени, обрабатывая данные "на лету".
+Пример curl для обработки изображения:
+curl -X POST 'https://<your-space-url>/api/run/stream' \
+-F 'file=@/path/to/your/image.jpg' \
+-F 'command=magick' \
+-F 'args=["-", "-resize", "50%", "jpg:-"]' \
+--output "resized_image.jpg"
+
+Режим 2: Асинхронные задачи (для UI или очень долгих операций)
+Этот режим полезен, если вы создаете UI и не хотите, чтобы запрос "висел", или если конвертация занимает очень много времени (например, часы).
+Шаг 1: Создание задачи (POST /api/task/create)
+Мгновенно получаете ID зад��чи.
+Шаг 2: Проверка статуса (GET /api/task/status/:taskId)
+Периодически проверяете, как дела.
+Шаг 3: Скачивание (GET /api/download/:fileId)
+Когда задача готова, скачиваете результат.
 
 

index.js

@@ -2,7 +2,7 @@ import express from 'express';
 import multer from 'multer';
 import { spawn } from 'child_process';
 import { writeFile, unlink } from 'fs/promises';
-import { createReadStream } from 'fs';
+import { createReadStream, watch } from 'fs';
 import path from 'path';
 import { v4 as uuidv4 } from 'uuid';
 import fetch from 'node-fetch';
@@ -29,8 +29,7 @@ const downloadFile = async (url) => {
     return Buffer.from(arrayBuffer);
 };
 
-
-// --- ЭНДПОИНТ ДЛЯ ПОТОКОВОЙ ОБРАБОТКИ (ИСПРАВЛЕН) ---
+// --- "УМНЫЙ" ЭНДПОИНТ С НАСТОЯЩИМ LIVE-СТРИМИНГОМ ДЛЯ FFMPEG ---
 app.post('/api/run/stream', upload.single('file'), async (req, res) => {
     try {
         const { command, args: argsJson, file_url } = req.body;
@@ -54,49 +53,91 @@ app.post('/api/run/stream', upload.single('file'), async (req, res) => {
             return res.status(400).json({ error: 'A file must be provided via "file" or "file_url".' });
         }
         
-        const process = spawn(command, args);
-        
-        let stdoutChunks = [];
-        let stderrChunks = []; // <<< ДОБАВЛЕНО: Сбор ошибок
-        
-        process.stdout.on('data', (data) => stdoutChunks.push(data));
-        process.stderr.on('data', (data) => stderrChunks.push(data)); // <<< ДОБАВЛЕНО: Слушаем stderr
+        // --- СПЕЦИАЛЬНАЯ ЛОГИКА ДЛЯ FFMPEG (LIVE STREAMING) ---
+        if (command === 'ffmpeg') {
+            const inputFilePath = path.join(TEMP_DIR, `${uuidv4()}-input`);
+            const outputFilePath = path.join(TEMP_DIR, `${uuidv4()}-output`);
+            
+            await writeFile(inputFilePath, inputBuffer);
+
+            const processedArgs = args.map(arg => 
+                arg.replace('{INPUT_FILE}', inputFilePath)
+                   .replace('{OUTPUT_FILE}', outputFilePath)
+            );
+
+            const ffmpegProcess = spawn(command, processedArgs);
+
+            // Функция для очистки
+            const cleanup = () => {
+                ffmpegProcess.kill('SIGKILL'); // Убеждаемся, что процесс завершен
+                unlink(inputFilePath).catch(() => {});
+                unlink(outputFilePath).catch(() => {});
+            };
+
+            // Как только ffmpeg создаст выходной файл, начинаем его стримить
+            const watcher = watch(TEMP_DIR, (eventType, filename) => {
+                if (filename === path.basename(outputFilePath)) {
+                    res.setHeader('Content-Type', 'application/octet-stream');
+                    const outputStream = createReadStream(outputFilePath);
+                    outputStream.pipe(res);
+                    // Прекращаем следить за файлом после того, как он найден
+                    watcher.close();
+                }
+            });
 
-        process.on('error', (err) => { // <<< ДОБАВЛЕНО: Обработка ошибок запуска
-             res.status(500).json({
-                error: 'Failed to start command.',
-                message: err.message
+            // Если пользователь закроет соединение, убиваем ffmpeg и чистим файлы
+            res.on('close', () => {
+                cleanup();
             });
-        });
-        
-        process.on('close', (code) => {
-            if (code === 0) {
-                res.setHeader('Content-Type', 'application/octet-stream');
-                res.send(Buffer.concat(stdoutChunks));
-            } else {
-                // <<< ИЗМЕНЕНО: Отправляем подробную ошибку
-                const stderr = Buffer.concat(stderrChunks).toString('utf8');
-                res.status(500).json({
-                    error: 'Command execution failed.',
-                    code: code,
-                    stderr: stderr 
-                });
-            }
-        });
-        
-        process.stdin.write(inputBuffer);
-        process.stdin.end();
+
+            ffmpegProcess.on('close', (code) => {
+                watcher.close(); // На всякий случай
+                // Если ffmpeg завершился с ошибкой до того, как мы начали стримить
+                if (!res.headersSent) {
+                    res.status(500).json({ error: 'ffmpeg failed before output was generated.', code: code });
+                }
+                // Файлы будут удалены после завершения стрима (если он начался) или сразу
+                 setTimeout(cleanup, 100); // Небольшая задержка для завершения потока
+            });
+
+            ffmpegProcess.on('error', (err) => {
+                watcher.close();
+                if (!res.headersSent) {
+                     res.status(500).json({ error: 'Failed to start ffmpeg.', message: err.message });
+                }
+                 cleanup();
+            });
+
+        // --- ОБЫЧНАЯ ЛОГИКА ДЛЯ ДРУГИХ КОМАНД ---
+        } else {
+            const process = spawn(command, args);
+            let stdoutChunks = [];
+            let stderrChunks = [];
+            
+            process.stdout.on('data', (data) => stdoutChunks.push(data));
+            process.stderr.on('data', (data) => stderrChunks.push(data));
+
+            process.on('close', (code) => {
+                if (code === 0) {
+                    res.setHeader('Content-Type', 'application/octet-stream');
+                    res.send(Buffer.concat(stdoutChunks));
+                } else {
+                    const stderr = Buffer.concat(stderrChunks).toString('utf8');
+                    res.status(500).json({ error: 'Command execution failed.', code: code, stderr: stderr });
+                }
+            });
+
+            process.stdin.write(inputBuffer);
+            process.stdin.end();
+        }
 
     } catch (error) {
-        res.status(500).json({
-            error: 'Server error during stream processing.',
-            message: error.message
-        });
+        res.status(500).json({ error: 'Server error during stream processing.', message: error.message });
     }
 });
 
 
-// --- СИСТЕМА АСИНХРОННЫХ ЗАДАЧ ---
+// ... (остальной код для /api/task/* и /api/download/* без изменений) ...
 
 const executeTask = async (taskId) => {
     const task = tasks[taskId];
@@ -106,29 +147,19 @@ const executeTask = async (taskId) => {
     try {
         tasks[taskId].status = 'processing';
         tasks[taskId].startTime = Date.now();
-
         const originalName = task.payload.originalName?.replace(/[^a-zA-Z0-9._-]/g, '') || 'input';
         const inputFilePath = path.join(TEMP_DIR, `${uuidv4()}-${originalName}`);
         const outputFilePath = path.join(TEMP_DIR, `${uuidv4()}-${outputFilename || 'output'}`);
-        
         tempFiles.push(inputFilePath, outputFilePath);
         task.outputFilePath = outputFilePath;
-
-        const processedArgs = args.map(arg => 
-            arg.replace('{INPUT_FILE}', inputFilePath)
-               .replace('{OUTPUT_FILE}', outputFilePath)
-        );
-
+        const processedArgs = args.map(arg => arg.replace('{INPUT_FILE}', inputFilePath).replace('{OUTPUT_FILE}', outputFilePath));
         await writeFile(inputFilePath, inputBuffer);
-
         const process = spawn(command, processedArgs);
         let stderrOutput = '';
         let totalDuration = 0;
-
         process.stderr.on('data', (data) => {
             const stderrLine = data.toString();
             stderrOutput += stderrLine;
-
             if (!totalDuration) {
                 const durationMatch = stderrLine.match(/Duration: (\d{2}):(\d{2}):(\d{2})\.\d{2}/);
                 if (durationMatch) {
@@ -136,23 +167,19 @@ const executeTask = async (taskId) => {
                     task.estimatedTotalTime = totalDuration;
                 }
             }
-
             const timeMatch = stderrLine.match(/time=(\d{2}):(\d{2}):(\d{2})\.\d{2}/);
             if (timeMatch && totalDuration) {
                 const currentTime = parseInt(timeMatch[1]) * 3600 + parseInt(timeMatch[2]) * 60 + parseInt(timeMatch[3]);
                 task.progress = Math.min(100, Math.round((currentTime / totalDuration) * 100));
             }
         });
-
         await new Promise((resolve, reject) => {
             process.on('close', (code) => {
                 task.endTime = Date.now();
                 task.stderr = stderrOutput;
                 if (code === 0) {
                     task.status = 'completed';
-                    task.result = {
-                        download_url: `/api/download/${path.basename(outputFilePath)}`
-                    };
+                    task.result = { download_url: `/api/download/${path.basename(outputFilePath)}` };
                     resolve();
                 } else {
                     const error = new Error(`Process exited with code ${code}`);
@@ -162,96 +189,43 @@ const executeTask = async (taskId) => {
             });
             process.on('error', reject);
         });
-
     } catch (error) {
         tasks[taskId].status = 'failed';
         tasks[taskId].endTime = Date.now();
-        tasks[taskId].error = {
-            message: error.message,
-            code: error.code
-        };
-        for (const filePath of tempFiles) {
-            unlink(filePath).catch(() => {});
-        }
+        tasks[taskId].error = { message: error.message, code: error.code };
+        for (const filePath of tempFiles) { unlink(filePath).catch(() => {}); }
     }
 };
 
-app.get('/', (req, res) => {
-    res.send('Task-based remote execution server is ready.');
-});
+app.get('/', (req, res) => { res.send('Task-based remote execution server is ready.'); });
 
 app.post('/api/task/create', upload.single('file'), async (req, res) => {
     try {
         const { command, args: argsJson, file_url, output_filename } = req.body;
         const file = req.file;
-
         if (!command) return res.status(400).json({ error: 'Parameter "command" is required.' });
-        
         let args;
-        try {
-           args = argsJson ? JSON.parse(argsJson) : [];
-        } catch(e) {
-           return res.status(400).json({ error: 'Parameter "args" must be a valid JSON array.' });
-        }
-
+        try { args = argsJson ? JSON.parse(argsJson) : []; } catch(e) { return res.status(400).json({ error: 'Parameter "args" must be a valid JSON array.' }); }
         let inputBuffer;
-        if (file) {
-            inputBuffer = file.buffer;
-        } else if (file_url) {
-            inputBuffer = await downloadFile(file_url);
-        } else {
-            return res.status(400).json({ error: 'A file must be provided via "file" or "file_url".' });
-        }
-
+        if (file) { inputBuffer = file.buffer; } else if (file_url) { inputBuffer = await downloadFile(file_url); } else { return res.status(400).json({ error: 'A file must be provided via "file" or "file_url".' }); }
         const taskId = uuidv4();
-        tasks[taskId] = {
-            id: taskId,
-            status: 'queued',
-            progress: 0,
-            submittedAt: Date.now(),
-            payload: {
-                command,
-                args,
-                outputFilename: output_filename,
-                originalName: file?.originalname,
-                inputBuffer,
-            }
-        };
-
+        tasks[taskId] = { id: taskId, status: 'queued', progress: 0, submittedAt: Date.now(), payload: { command, args, outputFilename: output_filename, originalName: file?.originalname, inputBuffer, } };
         executeTask(taskId);
-
-        res.status(202).json({ 
-            message: "Task accepted.",
-            taskId: taskId,
-            status_url: `/api/task/status/${taskId}`
-        });
-
+        res.status(202).json({ message: "Task accepted.", taskId: taskId, status_url: `/api/task/status/${taskId}` });
     } catch (error) {
-        res.status(500).json({
-            error: 'Failed to create task.',
-            message: error.message,
-        });
+        res.status(500).json({ error: 'Failed to create task.', message: error.message });
     }
 });
 
 app.get('/api/task/status/:taskId', (req, res) => {
     const { taskId } = req.params;
     const task = tasks[taskId];
-
-    if (!task) {
-        return res.status(404).json({ error: 'Task not found.' });
-    }
-
-    const response = {
-        id: task.id,
-        status: task.status,
-    };
-
+    if (!task) { return res.status(404).json({ error: 'Task not found.' }); }
+    const response = { id: task.id, status: task.status };
     if (task.startTime) {
         const endTime = task.endTime || Date.now();
         response.elapsedTimeSeconds = Math.round((endTime - task.startTime) / 1000);
     }
-
     if (task.status === 'processing') {
         response.progress = task.progress;
         if (task.estimatedTotalTime && response.elapsedTimeSeconds) {
@@ -259,40 +233,23 @@ app.get('/api/task/status/:taskId', (req, res) => {
             response.estimatedTimeLeftSeconds = Math.max(0, remaining);
         }
     }
-    
-    if (task.status === 'completed') {
-        response.result = task.result;
-    }
-
-    if (task.status === 'failed') {
-        response.error = task.error;
-    }
-    
+    if (task.status === 'completed') { response.result = task.result; }
+    if (task.status === 'failed') { response.error = task.error; }
     res.status(200).json(response);
 });
 
 app.get('/api/download/:fileId', (req, res) => {
     const { fileId } = req.params;
-    if (fileId.includes('..')) {
-        return res.status(400).send('Invalid file ID.');
-    }
-
+    if (fileId.includes('..')) { return res.status(400).send('Invalid file ID.'); }
     const filePath = path.join(TEMP_DIR, fileId);
-    
     const stream = createReadStream(filePath);
     stream.on('error', (err) => {
-        if (err.code === 'ENOENT') {
-            res.status(404).send('File not found or has been cleaned up.');
-        } else {
-            res.status(500).send('Server error.');
-        }
+        if (err.code === 'ENOENT') { res.status(404).send('File not found or has been cleaned up.'); } else { res.status(500).send('Server error.'); }
     });
     res.setHeader('Content-Type', 'application/octet-stream');
     stream.pipe(res);
 });
 
-app.listen(PORT, () => {
-    startCleanupJob();
-});
+app.listen(PORT, () => { startCleanupJob(); });