Upload 5 files

Dockerfile

@@ -1,30 +1,19 @@
-# Используем официальный образ Node.js 18.
 FROM node:18-slim
 
-# ИСПРАВЛЕНИЕ: Установка ffmpeg
-# Обновляем список пакетов и устанавливаем ffmpeg.
-# -y автоматически отвечает 'да' на все запросы.
-# && rm -rf /var/lib/apt/lists/* очищает кэш после установки для уменьшения размера образа.
 RUN apt-get update && \
     apt-get install -y ffmpeg && \
     rm -rf /var/lib/apt/lists/*
 
-# Устанавливаем рабочую директорию внутри контейнера
 WORKDIR /usr/src/app
 
-# Копируем файлы package.json и package-lock.json
 COPY package*.json ./
 
-# Устанавливаем зависимости проекта
 RUN npm install --only=production
 
-# Копируем остальной код приложения в рабочую директорию
 COPY . .
 
-# Открываем порт, на котором будет работать приложение (стандартный для Spaces - 7860)
 EXPOSE 7860
 
-# Указываем команду для запуска приложения при старте контейнера
 CMD [ "node", "index.js" ]
 
 

README.md

@@ -1,10 +1,65 @@
----
-title: Ffmpeg Api
-emoji: 😻
-colorFrom: indigo
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+API для асинхронного выполнения команд
+Это API позволяет удаленно выполнять консольные команды в асинхронном режиме. Вы отправляете задачу и получаете ее ID, после чего можете отслеживать статус выполнения.
+Новый процесс работы
+Процесс теперь состоит из 3 шагов:
+Шаг 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'
+
+Ответ сервера (статус 202 Accepted):
+{
+    "message": "Task accepted.",
+    "taskId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+    "status_url": "/api/task/status/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+}
+
+Сохраните taskId для следующего шага.
+Шаг 2: Проверка статуса задачи
+Отправляйте GET-запросы на эндпоинт status_url, полученный на предыдущем шаге, чтобы отслеживать выполнение.
+Пример curl:
+curl 'https://<your-space-url>/api/task/status/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
+
+Возможные ответы:
+ * Задача в очереди или обрабатывается:
+   {
+    "id": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+    "status": "processing",
+    "elapsedTimeSeconds": 15,
+    "progress": 25,
+    "estimatedTimeLeftSeconds": 45
+}
+
+ * Задача успешно завершена:
+   {
+    "id": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+    "status": "completed",
+    "elapsedTimeSeconds": 60,
+    "result": {
+        "download_url": "/api/download/yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy-converted.mp4"
+    }
+}
+
+ * Задача завершилась с ошибкой:
+   {
+    "id": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+    "status": "failed",
+    "elapsedTimeSeconds": 10,
+    "error": {
+        "message": "Process exited with code 1",
+        "code": 1
+    }
+}
+
+Шаг 3: Скачивание результата
+Когда задача получает статус completed, используйте download_url из ответа для скачивания готового файла.
+Пример curl:
+# Используйте download_url из успешного ответа на Шаге 2
+curl 'https://<your-space-url>/api/download/yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy-converted.mp4' \
+--output "final_video.mp4"
+
+Этот новый подход более надежен для длительных операций и дает вам полный контроль над отслеживанием процесса.

cleanup.js

@@ -1,52 +1,58 @@
 import cron from 'node-cron';
 import fs from 'fs/promises';
 import path from 'path';
+import { tasks } from './index.js';
 
-// ИСПРАВЛЕНИЕ: Используем глобальную временную директорию /tmp.
 const TEMP_DIR = '/tmp';
-const MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 часа в миллисекундах
+const MAX_AGE_MS = 24 * 60 * 60 * 1000;
 
 async function cleanupOldFiles() {
-    console.log('Запуск задачи по очистке старых файлов...');
     try {
         const files = await fs.readdir(TEMP_DIR);
         const now = Date.now();
 
         for (const file of files) {
-            // Очищаем только файлы, созданные нашим приложением (у них UUID в имени)
-            // Это мера предосторожности, чтобы не удалить чужие файлы в /tmp
             if (/\b[0-9a-f]{8}\b-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-\b[0-9a-f]{12}\b/i.test(file)) {
-                 const filePath = path.join(TEMP_DIR, file);
+                const filePath = path.join(TEMP_DIR, file);
                 try {
                     const stats = await fs.stat(filePath);
-                    const fileAge = now - stats.mtime.getTime();
-
-                    if (fileAge > MAX_AGE_MS) {
+                    if (now - stats.mtime.getTime() > MAX_AGE_MS) {
                         await fs.unlink(filePath);
-                        console.log(`Удален старый файл: ${filePath}`);
                     }
                 } catch (statError) {
                     if (statError.code !== 'ENOENT') {
-                        console.error(`Не удалось получить информацию о файле ${filePath}:`, statError);
+                        console.error(`Failed to stat file ${filePath}:`, statError);
                     }
                 }
             }
         }
     } catch (readDirError) {
-        if (readDirError.code === 'ENOENT') {
-            // Этого не должно случиться с /tmp, но на всякий случай.
-            console.log('Временная директория не существует, очистка не требуется.');
-        } else {
-            console.error('Ошибка при чтении временной директории:', readDirError);
+        if (readDirError.code !== 'ENOENT') {
+            console.error('Error reading temp directory:', readDirError);
+        }
+    }
+}
+
+function cleanupOldTasks() {
+    const now = Date.now();
+    for (const taskId in tasks) {
+        const task = tasks[taskId];
+        if (task.submittedAt && (now - task.submittedAt > MAX_AGE_MS)) {
+            if (task.outputFilePath) {
+                fs.unlink(task.outputFilePath).catch(() => {});
+            }
+            delete tasks[taskId];
         }
     }
-    console.log('Очистка завершена.');
 }
 
 export function startCleanupJob() {
-    cleanupOldFiles(); 
-    cron.schedule('0 * * * *', cleanupOldFiles);
-    console.log('Задача по очистке запланирована на запуск каждый час.');
+    cleanupOldFiles();
+    cleanupOldTasks();
+    cron.schedule('0 * * * *', () => {
+        cleanupOldFiles();
+        cleanupOldTasks();
+    });
 }
 
 

index.js

@@ -1,130 +1,127 @@
 import express from 'express';
 import multer from 'multer';
 import { spawn } from 'child_process';
-import { writeFile, unlink, createReadStream } from 'fs';
+import { writeFile, unlink, createReadStream } from 'fs/promises';
 import path from 'path';
 import { v4 as uuidv4 } from 'uuid';
 import fetch from 'node-fetch';
 import { startCleanupJob } from './cleanup.js';
 
-// --- НАСТРОЙКА ---
-// ИСПРАВЛЕНИЕ: Используем глобальную временную директорию /tmp, которая всегда доступна для записи.
-const TEMP_DIR = '/tmp'; 
-
+const TEMP_DIR = '/tmp';
 const app = express();
 const PORT = process.env.PORT || 7860;
 
-console.log(`Используется временная директория: ${TEMP_DIR}`);
+export const tasks = {};
 
-// --- MIDDLEWARE ---
 app.use(express.json());
 app.use(express.urlencoded({ extended: true }));
 
 const storage = multer.memoryStorage();
 const upload = multer({ storage: storage });
 
-// --- ЛОГИКА ---
-
-const executeCommand = (command, args, inputBuffer = null) => {
-    return new Promise((resolve, reject) => {
-        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) => {
-            const stdout = Buffer.concat(stdoutChunks);
-            const stderr = Buffer.concat(stderrChunks).toString('utf8');
-            if (code === 0) {
-                resolve({ stdout, stderr });
-            } else {
-                const error = new Error(`Процесс завершился с кодом ${code}.\nStderr: ${stderr}`);
-                error.code = code;
-                error.stderr = stderr;
-                reject(error);
-            }
-        });
-        
-        process.on('error', (err) => reject(err));
-
-        if (inputBuffer) {
-            process.stdin.write(inputBuffer);
-            process.stdin.end();
-        }
-    });
-};
-
 const downloadFile = async (url) => {
     const response = await fetch(url);
     if (!response.ok) {
-        throw new Error(`Не удалось скачать файл: ${response.statusText}`);
+        throw new Error(`Failed to download file: ${response.statusText}`);
     }
     const arrayBuffer = await response.arrayBuffer();
     return Buffer.from(arrayBuffer);
 };
 
-// --- МАРШРУТЫ API ---
-
-app.get('/', (req, res) => {
-    res.send('Сервер удаленного выполнения команд готов к работе!');
-});
+const executeTask = async (taskId) => {
+    const task = tasks[taskId];
+    const { command, args, inputBuffer, outputFilename } = task.payload;
+    const tempFiles = [];
 
-app.post('/api/run/stream', upload.single('file'), async (req, res) => {
     try {
-        const { command, args: argsJson, file_url } = req.body;
-        const file = req.file;
+        tasks[taskId].status = 'processing';
+        tasks[taskId].startTime = Date.now();
 
-        if (!command) return res.status(400).send({ error: 'Параметр "command" обязателен.' });
+        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'}`);
         
-        let args;
-        try {
-           args = argsJson ? JSON.parse(argsJson) : [];
-        } catch(e) {
-           return res.status(400).send({ error: 'Параметр "args" должен быть валидным JSON массивом.' });
-        }
+        tempFiles.push(inputFilePath, outputFilePath);
+        task.outputFilePath = outputFilePath;
 
-        let inputBuffer;
-        if (file) {
-            inputBuffer = file.buffer;
-        } else if (file_url) {
-            inputBuffer = await downloadFile(file_url);
-        } else {
-            return res.status(400).send({ error: 'Необходимо предоставить файл через "file" или "file_url".' });
-        }
+        const processedArgs = args.map(arg => 
+            arg.replace('{INPUT_FILE}', inputFilePath)
+               .replace('{OUTPUT_FILE}', outputFilePath)
+        );
 
-        const { stdout, stderr } = await executeCommand(command, args, inputBuffer);
-        
-        console.log(`Stderr для ${command}: ${stderr}`);
-        
-        res.setHeader('Content-Type', 'application/octet-stream');
-        res.send(stdout);
+        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) {
+                    totalDuration = parseInt(durationMatch[1]) * 3600 + parseInt(durationMatch[2]) * 60 + parseInt(durationMatch[3]);
+                    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)}`
+                    };
+                    resolve();
+                } else {
+                    const error = new Error(`Process exited with code ${code}`);
+                    error.code = code;
+                    reject(error);
+                }
+            });
+            process.on('error', reject);
+        });
 
     } catch (error) {
-        console.error('Ошибка в /api/run/stream:', error);
-        res.status(500).send({
-            error: 'Ошибка выполнения команды.',
+        tasks[taskId].status = 'failed';
+        tasks[taskId].endTime = Date.now();
+        tasks[taskId].error = {
             message: error.message,
-            stderr: error.stderr || 'N/A'
-        });
+            code: error.code
+        };
+        for (const filePath of tempFiles) {
+            unlink(filePath).catch(() => {});
+        }
     }
-});
+};
 
-app.post('/api/run/file', upload.single('file'), async (req, res) => {
-    const tempFiles = [];
+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).send({ error: 'Параметр "command" обязателен.' });
+        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).send({ error: 'Параметр "args" должен быть валидным JSON массивом.' });
+           return res.status(400).json({ error: 'Parameter "args" must be a valid JSON array.' });
         }
 
         let inputBuffer;
@@ -133,88 +130,104 @@ app.post('/api/run/file', upload.single('file'), async (req, res) => {
         } else if (file_url) {
             inputBuffer = await downloadFile(file_url);
         } else {
-            return res.status(400).send({ error: 'Необходимо предоставить файл через "file" или "file_url".' });
+            return res.status(400).json({ error: 'A file must be provided via "file" or "file_url".' });
         }
-        
-        // Получаем имя файла из загрузки, или используем 'input' как запасной вариант
-        const originalName = file?.originalname?.replace(/[^a-zA-Z0-9._-]/g, '') || 'input';
-        
-        const inputFilePath = path.join(TEMP_DIR, `${uuidv4()}-${originalName}`);
-        const outputFilePath = path.join(TEMP_DIR, `${uuidv4()}-${output_filename || 'output'}`);
-        
-        tempFiles.push(inputFilePath, outputFilePath);
 
-        const processedArgs = args.map(arg => 
-            arg.replace('{INPUT_FILE}', inputFilePath)
-               .replace('{OUTPUT_FILE}', outputFilePath)
-        );
+        const taskId = uuidv4();
+        tasks[taskId] = {
+            id: taskId,
+            status: 'queued',
+            progress: 0,
+            submittedAt: Date.now(),
+            payload: {
+                command,
+                args,
+                outputFilename: output_filename,
+                originalName: file?.originalname,
+                inputBuffer,
+            }
+        };
 
-        await new Promise((resolve, reject) => {
-            writeFile(inputFilePath, inputBuffer, (err) => {
-                if (err) {
-                    console.error("Ошибка записи входного файла:", err);
-                    return reject(err);
-                }
-                resolve();
-            });
-        });
+        executeTask(taskId);
 
-        const { stderr } = await executeCommand(command, processedArgs);
-        console.log(`Stderr д��я ${command}: ${stderr}`);
-        
-        const fileId = path.basename(outputFilePath);
-        res.status(200).json({
-            message: 'Команда выполнена успешно.',
-            download_url: `/api/download/${fileId}`,
-            stderr: stderr
+        res.status(202).json({ 
+            message: "Task accepted.",
+            taskId: taskId,
+            status_url: `/api/task/status/${taskId}`
         });
 
     } catch (error) {
-        console.error('Ошибка в /api/run/file:', error);
-        
-        for (const filePath of tempFiles) {
-            unlink(filePath, (err) => {
-                if (err) {
-                     // Не выводим ошибку, если файла просто нет (уже удален или не был создан)
-                    if(err.code !== 'ENOENT') console.error(`Не удалось удалить временный файл ${filePath}:`, err);
-                }
-            });
-        }
-        
-        res.status(500).send({
-            error: 'Ошибка выполнения команды.',
+        res.status(500).json({
+            error: 'Failed to create task.',
             message: error.message,
-            stderr: error.stderr || 'N/A'
         });
     }
 });
 
+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.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) {
+            const remaining = task.estimatedTotalTime - response.elapsedTimeSeconds;
+            response.estimatedTimeLeftSeconds = Math.max(0, remaining);
+        }
+    }
+    
+    if (task.status === 'completed') {
+        response.result = task.result;
+    }
+
+    if (task.status === 'failed') {
+        response.error = task.error;
+    }
+    
+    // For debugging, optionally include stderr
+    // response.stderr = task.stderr;
+
+    res.status(200).json(response);
+});
+
 app.get('/api/download/:fileId', (req, res) => {
     const { fileId } = req.params;
     if (fileId.includes('..')) {
-        return res.status(400).send('Неверный ID файла.');
+        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('Файл не найден или был удален.');
-        } else {
-            console.error(`Ошибка чтения файла ${filePath}:`, err);
-            res.status(500).send('Ошибка сервера.');
-        }
-    });
-    
-    res.setHeader('Content-Type', 'application/octet-stream');
-    stream.pipe(res);
+    createReadStream(filePath)
+        .then(stream => {
+            res.setHeader('Content-Type', 'application/octet-stream');
+            stream.pipe(res);
+        })
+        .catch(err => {
+            if (err.code === 'ENOENT') {
+                res.status(404).send('File not found or has been cleaned up.');
+            } else {
+                res.status(500).send('Server error.');
+            }
+        });
 });
 
-// --- ЗАПУСК СЕРВЕРА И ОЧИСТКИ ---
-
 app.listen(PORT, () => {
-    console.log(`Сервер запущен на порту ${PORT}`);
     startCleanupJob();
 });
 

package.json

@@ -1,22 +1,12 @@
 {
-  "name": "huggingface-remote-runner",
-  "version": "1.0.0",
-  "description": "API для удаленного выполнения команд в Hugging Face Space",
+  "name": "huggingface-ffmpeg-api",
+  "version": "2.0.0",
+  "description": "ffmpeg rest api",
   "main": "index.js",
   "type": "module",
   "scripts": {
-    "start": "node index.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "start": "node index.js"
   },
-  "keywords": [
-    "huggingface",
-    "api",
-    "remote-execution",
-    "nodejs",
-    "esm"
-  ],
-  "author": "",
-  "license": "ISC",
   "dependencies": {
     "express": "^4.18.2",
     "multer": "^1.4.5-lts.1",
@@ -26,3 +16,4 @@
   }
 }
 
+