Upload 4 files

Dockerfile

@@ -1,5 +1,27 @@
-FROM kazhar/ffmpeg-api:latest
+# Используем официальный образ Node.js 18.
+# ESM-модули и fetch API стабильны в этой версии.
+FROM node:18-slim
 
-ENV EXTERNAL_PORT=7860
+# Устанавливаем рабочую директорию внутри контейнера
+WORKDIR /usr/src/app
 
+# Копируем файлы package.json и package-lock.json
+COPY package*.json ./
+
+# Устанавливаем зависимости проекта
+# --only=production гарантирует, что установятся только производственные зависимости
+RUN npm install --only=production
+
+# Копируем остальной код приложения в рабочую директорию
+COPY . .
+
+# Создаем директорию для временных файлов
+RUN mkdir -p /tmp/huggingface-runner
+
+# Открываем порт, на котором будет работать приложение (стандартный для Spaces - 7860)
 EXPOSE 7860
+
+# Указываем команду для запуска приложения при старте контейнера
+# Используем массив для корректной обработки сигналов
+CMD [ "node", "index.js" ]
+

cleanup.js

@@ -0,0 +1,55 @@
+import cron from 'node-cron';
+import fs from 'fs/promises';
+import path from 'path';
+
+const TEMP_DIR = '/tmp/huggingface-runner';
+const MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 часа в миллисекундах
+
+/**
+ * Удаляет старые файлы из временной директории.
+ */
+async function cleanupOldFiles() {
+    console.log('Запуск задачи по очистке старых файлов...');
+    try {
+        const files = await fs.readdir(TEMP_DIR);
+        const now = Date.now();
+
+        for (const file of files) {
+            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) {
+                    await fs.unlink(filePath);
+                    console.log(`Удален старый файл: ${filePath}`);
+                }
+            } catch (statError) {
+                // Если файл был удален между readdir и stat, просто игнорируем ошибку
+                if (statError.code !== 'ENOENT') {
+                    console.error(`Не удалось получить информацию о файле ${filePath}:`, statError);
+                }
+            }
+        }
+    } catch (readDirError) {
+        if (readDirError.code === 'ENOENT') {
+            console.log('Временная директория не существует, очистка не требуется.');
+        } else {
+            console.error('Ошибка при чтении временной директории:', readDirError);
+        }
+    }
+    console.log('Очистка завершена.');
+}
+
+/**
+ * Запускает периодическую задачу (cron job) для очистки.
+ * Задача будет выполняться каждый час.
+ */
+export function startCleanupJob() {
+    // Запускаем сразу при старте, а затем каждый час
+    cleanupOldFiles(); 
+    
+    cron.schedule('0 * * * *', cleanupOldFiles); // '0 * * * *' - каждую 0-ю минуту каждого часа
+    console.log('Задача по очистке запланирована на запуск каждый час.');
+}
+

index.js

@@ -0,0 +1,255 @@
+import express from 'express';
+import multer from 'multer';
+import { spawn } from 'child_process';
+import { writeFile, unlink, createReadStream } from 'fs';
+import { fileURLToPath } from 'url';
+import path, { dirname } from 'path';
+import { v4 as uuidv4 } from 'uuid';
+import fetch from 'node-fetch';
+import { startCleanupJob } from './cleanup.js';
+
+// --- НАСТРОЙКА ---
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TEMP_DIR = '/tmp/huggingface-runner'; // Директория для временных файлов
+
+const app = express();
+const PORT = process.env.PORT || 7860; // Hugging Face Spaces использует порт 7860
+
+// --- MIDDLEWARE ---
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// Настройка Multer для загрузки файлов в память
+const storage = multer.memoryStorage();
+const upload = multer({ storage: storage });
+
+// --- ЛОГИКА ---
+
+/**
+ * Функция для выполнения внешней команды.
+ * @param {string} command - Команда для выполнения (например, 'ffmpeg').
+ * @param {Array<string>} args - Аргументы для команды.
+ * @param {Buffer | null} inputBuffer - Входные данные для stdin.
+ * @returns {Promise<{stdout: Buffer, stderr: string}>} - Промис с результатом.
+ */
+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();
+        }
+    });
+};
+
+
+/**
+ * Скачивает файл по URL.
+ * @param {string} url - URL файла.
+ * @returns {Promise<Buffer>} - Промис с буфером файла.
+ */
+const downloadFile = async (url) => {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Не удалось скачать файл: ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+};
+
+// --- МАРШРУТЫ API ---
+
+app.get('/', (req, res) => {
+    res.send('Сервер удаленного выполнения команд готов к работе!');
+});
+
+
+/**
+ * МАРШРУТ 1: Потоковая обработка (без сохранения)
+ * Принимает файл (загрузка или URL) и команду, возвращает результат потоком.
+ * POST /api/run/stream
+ * Body: { command: "ваша команда", args: ["аргумент1", "аргумент2"], file_url?: "URL файла" }
+ * или multipart/form-data с полями command, args и file.
+ */
+app.post('/api/run/stream', upload.single('file'), async (req, res) => {
+    try {
+        const { command, args: argsJson, file_url } = req.body;
+        const file = req.file;
+
+        if (!command) {
+            return res.status(400).send({ error: 'Параметр "command" обязателен.' });
+        }
+        
+        let args;
+        try {
+           args = argsJson ? JSON.parse(argsJson) : [];
+        } catch(e) {
+           return res.status(400).send({ error: 'Параметр "args" должен быть валидным JSON массивом.' });
+        }
+
+        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 { stdout, stderr } = await executeCommand(command, args, inputBuffer);
+        
+        console.log(`Stderr для ${command}: ${stderr}`);
+        
+        // Отправляем результат как бинарные данные
+        res.setHeader('Content-Type', 'application/octet-stream');
+        res.send(stdout);
+
+    } catch (error) {
+        console.error('Ошибка в /api/run/stream:', error);
+        res.status(500).send({
+            error: 'Ошибка выполнения команды.',
+            message: error.message,
+            stderr: error.stderr || 'N/A'
+        });
+    }
+});
+
+
+/**
+ * МАРШРУТ 2: Обработка с сохранением файла
+ * Сохраняет файл, выполняет команду, сохраняет результат и отдает ссылку.
+ * POST /api/run/file
+ */
+app.post('/api/run/file', upload.single('file'), async (req, res) => {
+    const tempFiles = []; // Массив для отслеживания созданных файлов
+
+    try {
+        const { command, args: argsJson, file_url, output_filename } = req.body;
+        const file = req.file;
+
+        if (!command) {
+            return res.status(400).send({ error: 'Параметр "command" обязателен.' });
+        }
+        
+        let args;
+        try {
+           args = argsJson ? JSON.parse(argsJson) : [];
+        } catch(e) {
+           return res.status(400).send({ error: 'Параметр "args" должен быть валидным JSON массивом.' });
+        }
+
+        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 inputFilePath = path.join(TEMP_DIR, `${uuidv4()}-${file?.originalname || 'input'}`);
+        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)
+        );
+
+        // Сохраняем входной файл
+        await new Promise((resolve, reject) => {
+            writeFile(inputFilePath, inputBuffer, (err) => err ? reject(err) : resolve());
+        });
+
+        // Выполняем команду
+        // Здесь stdin не используется, так как команда работает с файлами на диске
+        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
+        });
+
+    } catch (error) {
+        console.error('Ошибка в /api/run/file:', error);
+        
+        // Удаляем временные файлы в случае ошибки
+        for (const filePath of tempFiles) {
+            unlink(filePath, (err) => {
+                if (err) console.error(`Не удалось удалить временный файл ${filePath}:`, err);
+            });
+        }
+        
+        res.status(500).send({
+            error: 'Ошибка выполнения команды.',
+            message: error.message,
+            stderr: error.stderr || 'N/A'
+        });
+    }
+});
+
+
+/**
+ * МАРШРУТ 3: Скачивание файла по ID
+ * GET /api/download/:fileId
+ */
+app.get('/api/download/:fileId', (req, res) => {
+    const { fileId } = req.params;
+    // Важно: проверяем, что fileId не содержит ".." для предотвращения выхода из директории
+    if (fileId.includes('..')) {
+        return res.status(400).send('Неверный 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 {
+            res.status(500).send('Ошибка сервера.');
+        }
+    });
+    
+    res.setHeader('Content-Type', 'application/octet-stream');
+    stream.pipe(res);
+});
+
+
+// --- ЗАПУСК СЕРВЕРА И ОЧИСТКИ ---
+
+app.listen(PORT, () => {
+    console.log(`Сервер запущен на порту ${PORT}`);
+    // Запускаем задачу по очистке старых файлов
+    startCleanupJob();
+});
+

package.json

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