Upload 5 files

.dockerignore

@@ -0,0 +1,7 @@
+node_modules
+npm-debug.log
+uploads/*
+.git
+.gitignore
+README.md
+.env

DEPLOYMENT.md

@@ -0,0 +1,171 @@
+# Hugging Face Deployment - Step by Step
+
+## Step 1: Hugging Face Account එකක් හදාගන්න
+
+1. https://huggingface.co/join වෙබ් අඩවියට යන්න
+2. Email එකක් දාලා Sign Up කරන්න
+3. Email එකේ verification link එක click කරන්න
+4. Login වෙන්න
+
+## Step 2: නව Space එකක් Create කරන්න
+
+1. Profile picture එක click කරන්න (top right corner)
+2. **"New Space"** button එක click කරන්න
+3. විස්තර fill කරන්න:
+   - **Space name**: `dulaksha-stream` (හෝ ඕන නමක්)
+   - **License**: MIT
+   - **Select SDK**: **Docker** (මේක select කරන්න ඕනේ)
+   - **Space hardware**: CPU basic - Free
+4. **"Create Space"** click කරන්න
+
+## Step 3: Files Upload කරන්න
+
+### Method 1: Web Interface එකෙන් (Easy)
+
+1. **"Files"** tab එක click කරන්න
+2. **"Add file"** > **"Upload files"** click කරන්න
+3. මේ files upload කරන්න එකින් එක:
+   - `server.js`
+   - `package.json`
+   - `Dockerfile`
+   - `.dockerignore`
+4. Upload වෙලා නැති files තියෙනවනම් repeat කරන්න
+
+### Method 2: Git එකෙන් (Advanced)
+
+```bash
+git clone https://huggingface.co/spaces/YOUR-USERNAME/dulaksha-stream
+cd dulaksha-stream
+# Copy all files to this folder
+git add .
+git commit -m "Initial commit"
+git push
+```
+
+## Step 4: Build එක Wait කරන්න
+
+1. **"App"** tab එකට යන්න
+2. **"Building"** status එක පෙන්නන එක බලන්න
+3. **5-10 minutes** විතර wait කරන්න
+4. **"Running"** කියලා status එක change වෙනකල් wait කරන්න
+
+Build එක fail වෙනවනම්:
+- **"Logs"** tab එක check කරන්න
+- Error message එක copy කරන්න
+
+## Step 5: URL එක ගන්න
+
+Build එක success වුණාම ඔයාගේ app එක මේ URL එකේ available වෙයි:
+
+```
+https://YOUR-USERNAME-dulaksha-stream.hf.space
+```
+
+උදාහරණ:
+```
+https://dulaksha-dulaksha-stream.hf.space
+```
+
+## Step 6: Test කරන්න
+
+### Browser එකෙන් Test:
+1. URL එක browser එකේ open කරන්න
+2. Server running කියලා පෙන්වන්න ඕන
+
+### Video Upload Test (Postman):
+
+1. Postman open කරන්න
+2. **New Request** create කරන්න
+3. Settings:
+   - **Method**: POST
+   - **URL**: `https://YOUR-USERNAME-dulaksha-stream.hf.space/upload`
+   - **Body**: form-data
+   - **Key**: `file` (type: File)
+   - **Value**: video file එකක් select කරන්න
+4. **Send** click කරන්න
+
+### cURL එකෙන් Test:
+
+```bash
+curl -X POST -F "file=@video.mp4" https://YOUR-USERNAME-dulaksha-stream.hf.space/upload
+```
+
+## Step 7: Response එක Check කරන්න
+
+Upload success වුණාම මේ විදිහේ response එකක් එනවා:
+
+```json
+{
+  "status": "success",
+  "stream_link": "https://YOUR-SPACE.hf.space/stream/123456/video.mp4",
+  "qualities": ["1080p", "720p", "480p"]
+}
+```
+
+## Video Quality Conversion
+
+- **2160p (4K) video**: Convert to 1080p, 720p, 480p
+- **1080p video**: Convert to 1080p, 720p, 480p
+- **720p video**: Convert to 720p, 480p
+- **480p video**: Keep as 480p
+
+## API Endpoints
+
+### Upload Video
+```
+POST /upload
+Content-Type: multipart/form-data
+Body: file (video file)
+```
+
+### Stream File
+```
+GET /stream/:id/:filename
+```
+
+### Download File
+```
+GET /download/:id/:filename
+```
+
+## Important Notes
+
+- **Bot connect වෙන්න විනාඩි 2-3ක් යනවා** - First upload එකට wait කරන්න
+- **Large files වලට processing time වැඩියි** - 4K videos වලට 10-20 minutes යනවා
+- **Stream links permanent** - කවදාවත් expire වෙන්නේ නැහැ
+- **All files Telegram එකේ store වෙනවා** - Backup එකක් විදිහට
+
+## Common Issues
+
+### 1. Build Failed
+**Solution**: Dockerfile එක හරියටම copy වෙලා තියෙනවද check කරන්න
+
+### 2. Service Unavailable
+**Solution**: විනාඩි 2-3ක් wait කරලා retry කරන්න (bot connecting)
+
+### 3. Upload Timeout
+**Solution**: 
+- File size අඩු කරන්න
+- Better hardware tier එකක් select කරන්න (Settings > Hardware)
+
+### 4. FFmpeg Error
+**Solution**: Video file එක corrupt වෙලා නැද්ද check කරන්න
+
+## Hardware Upgrade (Optional)
+
+Free tier slow නම්:
+1. Space Settings > Hardware
+2. Upgrade කරන්න:
+   - CPU basic (Free) → CPU upgrade ($0.60/hour)
+   - GPU එකක් select කරන්න (faster conversion)
+
+## Files නෙරපන්න ඕනේ නම්
+
+```bash
+# Hugging Face Space එකේ
+Files > Delete කරන්න files
+```
+
+---
+
+**සියලු files මේ folder එකේ තියෙනවා. Upload කරන්න විතරයි ඕන!**

Dockerfile

@@ -0,0 +1,20 @@
+FROM node:18-slim
+
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    python3 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY package*.json ./
+
+RUN npm install
+
+COPY . .
+
+RUN mkdir -p uploads
+
+EXPOSE 7860
+
+CMD ["npm", "start"]

package.json

@@ -0,0 +1,20 @@
+{
+  "name": "dulaksha-stream",
+  "version": "1.0.0",
+  "description": "Video streaming service with multi-quality HLS support",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "multer": "^1.4.5-lts.1",
+    "telegram": "^2.22.2",
+    "input": "^1.0.1",
+    "fluent-ffmpeg": "^2.1.2",
+    "ffmpeg-static": "^5.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

server.js

@@ -0,0 +1,307 @@
+const express = require("express");
+const multer = require("multer");
+const { TelegramClient } = require("telegram");
+const { StringSession } = require("telegram/sessions");
+const input = require("input");
+const fs = require("fs");
+const path = require("path");
+const ffmpeg = require("fluent-ffmpeg");
+const ffmpegPath = require("ffmpeg-static");
+
+ffmpeg.setFfmpegPath(ffmpegPath);
+
+const app = express();
+const port = process.env.PORT || 7860;
+
+const API_ID = 24947404;
+const API_HASH = "a27b63b5e9a4c4e9279d1db641aca338";
+const BOT_TOKEN = "8300006322:AAHnZf0xlt5mrzlaBjXYmVceZwo3xmwTZaA";
+const BIN_CHANNEL = -1003569314973;
+const SYSTEM_URL = process.env.SPACE_HOST 
+    ? `https://${process.env.SPACE_ID.replace('/', '-')}-${process.env.SPACE_HOST}`
+    : "http://localhost:7860";
+
+const clients = [];
+const upload = multer({ dest: "uploads/" });
+
+app.use(express.json());
+
+async function getNextClient() {
+    const stringSession = new StringSession("");
+    const client = new TelegramClient(stringSession, API_ID, API_HASH, {
+        connectionRetries: 5,
+    });
+    
+    await client.start({
+        botAuthToken: BOT_TOKEN,
+    });
+    
+    clients.push(client);
+    return client;
+}
+
+async function startAllBots() {
+    console.log("Starting Dulaksha Stream bot...");
+    await getNextClient();
+    console.log("Bot connected successfully!");
+}
+
+function getVideoResolution(inputPath) {
+    return new Promise((resolve, reject) => {
+        ffmpeg.ffprobe(inputPath, (err, metadata) => {
+            if (err) return reject(err);
+            const videoStream = metadata.streams.find(s => s.codec_type === 'video');
+            if (!videoStream) return reject(new Error("No video stream found"));
+            resolve({ width: videoStream.width, height: videoStream.height });
+        });
+    });
+}
+
+function convertToMultiQualityHLS(inputPath, outputDir) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const resolution = await getVideoResolution(inputPath);
+            const height = resolution.height;
+            
+            const qualities = [];
+            if (height >= 2160) {
+                qualities.push({ name: "1080p", height: 1080, bitrate: "5000k" });
+                qualities.push({ name: "720p", height: 720, bitrate: "2800k" });
+                qualities.push({ name: "480p", height: 480, bitrate: "1400k" });
+            } else if (height >= 1080) {
+                qualities.push({ name: "1080p", height: 1080, bitrate: "5000k" });
+                qualities.push({ name: "720p", height: 720, bitrate: "2800k" });
+                qualities.push({ name: "480p", height: 480, bitrate: "1400k" });
+            } else if (height >= 720) {
+                qualities.push({ name: "720p", height: 720, bitrate: "2800k" });
+                qualities.push({ name: "480p", height: 480, bitrate: "1400k" });
+            } else {
+                qualities.push({ name: "480p", height: 480, bitrate: "1400k" });
+            }
+            
+            const masterPlaylist = path.join(outputDir, "master.m3u8");
+            let masterContent = "#EXTM3U\n#EXT-X-VERSION:3\n";
+            
+            const conversionPromises = qualities.map((quality, index) => {
+                return new Promise((res, rej) => {
+                    const qualityDir = path.join(outputDir, quality.name);
+                    fs.mkdirSync(qualityDir, { recursive: true });
+                    const playlistPath = path.join(qualityDir, "index.m3u8");
+                    
+                    ffmpeg(inputPath)
+                        .outputOptions([
+                            `-vf scale=-2:${quality.height}`,
+                            `-c:v libx264`,
+                            `-b:v ${quality.bitrate}`,
+                            `-c:a aac`,
+                            `-b:a 128k`,
+                            `-start_number 0`,
+                            `-hls_time 10`,
+                            `-hls_list_size 0`,
+                            `-f hls`
+                        ])
+                        .output(playlistPath)
+                        .on("end", () => {
+                            masterContent += `#EXT-X-STREAM-INF:BANDWIDTH=${parseInt(quality.bitrate) * 1000},RESOLUTION=${Math.floor(quality.height * 16 / 9)}x${quality.height}\n`;
+                            masterContent += `${quality.name}/index.m3u8\n`;
+                            res();
+                        })
+                        .on("error", rej)
+                        .run();
+                });
+            });
+            
+            await Promise.all(conversionPromises);
+            
+            fs.writeFileSync(masterPlaylist, masterContent);
+            resolve(masterPlaylist);
+            
+        } catch (err) {
+            reject(err);
+        }
+    });
+}
+
+async function uploadHLSFiles(client, hlsDir, originalName) {
+    const uploadedFiles = { qualities: {} };
+    
+    const masterPath = path.join(hlsDir, "master.m3u8");
+    const masterResult = await client.sendFile(BIN_CHANNEL, {
+        file: masterPath,
+        caption: `📂 ${originalName} - master.m3u8`,
+        forceDocument: true
+    });
+    uploadedFiles.master = masterResult.id;
+    
+    const qualityDirs = fs.readdirSync(hlsDir).filter(f => 
+        fs.statSync(path.join(hlsDir, f)).isDirectory()
+    );
+    
+    for (const qualityDir of qualityDirs) {
+        const qualityPath = path.join(hlsDir, qualityDir);
+        const files = fs.readdirSync(qualityPath);
+        
+        const m3u8File = files.find(f => f.endsWith(".m3u8"));
+        const tsFiles = files.filter(f => f.endsWith(".ts"));
+        
+        uploadedFiles.qualities[qualityDir] = { segments: [] };
+        
+        const m3u8Path = path.join(qualityPath, m3u8File);
+        const m3u8Result = await client.sendFile(BIN_CHANNEL, {
+            file: m3u8Path,
+            caption: `📂 ${originalName} - ${qualityDir}/index.m3u8`,
+            forceDocument: true
+        });
+        uploadedFiles.qualities[qualityDir].index = m3u8Result.id;
+        
+        for (const tsFile of tsFiles) {
+            const tsPath = path.join(qualityPath, tsFile);
+            const tsResult = await client.sendFile(BIN_CHANNEL, {
+                file: tsPath,
+                caption: `📂 ${originalName} - ${qualityDir}/${tsFile}`,
+                forceDocument: true
+            });
+            uploadedFiles.qualities[qualityDir].segments.push({
+                name: tsFile,
+                id: tsResult.id
+            });
+        }
+    }
+    
+    return uploadedFiles;
+}
+
+app.post("/upload", upload.single('file'), async (req, res) => {
+    if (!req.file) return res.status(400).json({ error: "No file" });
+    
+    const originalName = req.file.originalname;
+    const safeName = encodeURIComponent(originalName.replace(/\s+/g, '_'));
+    const extension = path.extname(originalName).toLowerCase();
+    const tempPath = req.file.path;
+    const newPath = tempPath + extension;
+    
+    const videoExtensions = ['.mp4', '.mkv', '.avi', '.mov', '.wmv', '.flv', '.webm'];
+    const isVideo = videoExtensions.includes(extension);
+    
+    try {
+        fs.renameSync(tempPath, newPath);
+        const client = clients[0] || await getNextClient();
+        if (!client) throw new Error("Server Busy");
+        
+        if (isVideo) {
+            const hlsDir = path.join("uploads", `hls_${Date.now()}`);
+            fs.mkdirSync(hlsDir, { recursive: true });
+            
+            await convertToMultiQualityHLS(newPath, hlsDir);
+            const hlsFiles = await uploadHLSFiles(client, hlsDir, originalName);
+            
+            fs.rmSync(hlsDir, { recursive: true, force: true });
+            if (fs.existsSync(newPath)) fs.unlinkSync(newPath);
+            
+            res.json({
+                status: "success",
+                stream_link: `${SYSTEM_URL}/stream/${hlsFiles.master}/${safeName}`,
+                qualities: Object.keys(hlsFiles.qualities)
+            });
+        } else {
+            const result = await client.sendFile(BIN_CHANNEL, {
+                file: newPath,
+                caption: `📂 Uploaded: ${originalName}`,
+                forceDocument: false
+            });
+            
+            if (fs.existsSync(newPath)) fs.unlinkSync(newPath);
+            
+            res.json({
+                status: "success",
+                link: `${SYSTEM_URL}/stream/${result.id}`,
+                stream_link: `${SYSTEM_URL}/stream/${result.id}/${safeName}`,
+                download_link: `${SYSTEM_URL}/download/${result.id}/${safeName}`
+            });
+        }
+    } catch (e) {
+        console.error("Upload error:", e);
+        res.status(500).json({ error: e.message });
+        if (fs.existsSync(newPath)) fs.unlinkSync(newPath);
+        else if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+    }
+});
+
+app.get("/stream/:id/:filename?", async (req, res) => {
+    try {
+        const messageId = parseInt(req.params.id);
+        const client = clients[0];
+        if (!client) return res.status(503).send("Service unavailable");
+        
+        const messages = await client.getMessages(BIN_CHANNEL, { ids: [messageId] });
+        const message = messages[0];
+        
+        if (!message || !message.media) {
+            return res.status(404).send("File not found");
+        }
+        
+        const fileSize = message.media.document.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.writeHead(206, {
+                "Content-Range": `bytes ${start}-${end}/${fileSize}`,
+                "Accept-Ranges": "bytes",
+                "Content-Length": chunkSize,
+                "Content-Type": "application/octet-stream"
+            });
+            
+            const buffer = await client.downloadMedia(message, {
+                offset: start,
+                limit: chunkSize
+            });
+            res.end(buffer);
+        } else {
+            res.writeHead(200, {
+                "Content-Length": fileSize,
+                "Content-Type": "application/octet-stream"
+            });
+            
+            const buffer = await client.downloadMedia(message);
+            res.end(buffer);
+        }
+    } catch (e) {
+        console.error("Stream error:", e);
+        res.status(500).send("Error streaming file");
+    }
+});
+
+app.get("/download/:id/:filename", async (req, res) => {
+    try {
+        const messageId = parseInt(req.params.id);
+        const filename = decodeURIComponent(req.params.filename);
+        const client = clients[0];
+        if (!client) return res.status(503).send("Service unavailable");
+        
+        const messages = await client.getMessages(BIN_CHANNEL, { ids: [messageId] });
+        const message = messages[0];
+        
+        if (!message || !message.media) {
+            return res.status(404).send("File not found");
+        }
+        
+        res.setHeader("Content-Disposition", `attachment; filename="${filename}"`);
+        res.setHeader("Content-Type", "application/octet-stream");
+        
+        const buffer = await client.downloadMedia(message);
+        res.end(buffer);
+    } catch (e) {
+        console.error("Download error:", e);
+        res.status(500).send("Error downloading file");
+    }
+});
+
+app.listen(port, () => {
+    console.log(`Dulaksha Stream Server Running on Port ${port}`);
+    startAllBots().catch(console.error);
+});