update

Dockerfile

@@ -1,25 +1,37 @@
-FROM node:20-slim
+FROM node:20-bullseye
 
-RUN apt update && apt install -y \
-    wget gnupg xvfb \
-    fonts-liberation libnss3 libxss1 libxcomposite1 libxrandr2 libgbm1 \
-    && wget -q https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb \
-    && apt install -y ./google-chrome-stable_current_amd64.deb \
-    && rm google-chrome-stable_current_amd64.deb \
-    && apt clean && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    python3 \
+    python3-pip \
+    python3-dev \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
 
-RUN mkdir -p /app/cache && chmod 777 -R /app
+RUN python3 -m pip install --upgrade pip && \
+    python3 -m pip install --no-cache-dir --upgrade \
+    spotdl \
+    yt-dlp
+
+RUN mkdir -p /app/downloads && \
+    mkdir -p /app/docs && \
+    mkdir -p /app/scrape && \
+    mkdir -p /app/public && \
+    chmod 777 -R /app/downloads && \
+    chmod 777 -R /app/public && \
+    chmod 777 -R /app/docs && \
+    chmod 777 -R /app/scrape
 
 WORKDIR /app
 
 COPY package*.json ./
-RUN npm install --production
+RUN npm install
 
 COPY . .
 
-EXPOSE 7860
+RUN touch /app/public/index.html && \
+    chmod 666 /app/public/index.html
+
+CMD ["node", "index.js"]
 
-CMD rm -f /tmp/.X99-lock && \
-    Xvfb :99 -screen 0 1024x768x24 & \
-    export DISPLAY=:99 && \
-    npm start
+EXPOSE 7860

api_test.py

@@ -1,26 +0,0 @@
-import asyncio
-import httpx
-
-async def main():
-    async with httpx.AsyncClient(timeout=30.0) as client:
-        resp1 = await client.post(
-            "http://localhost:8080/cloudflare",
-            json={
-                "domain": "https://olamovies.watch/generate",
-                "mode": "iuam",
-            },
-        )
-        print(resp1.json())
-
-        resp2 = await client.post(
-            "http://localhost:8080/cloudflare",
-            json={
-                "domain": "https://lksfy.com/",
-                "siteKey": "0x4AAAAAAA49NnPZwQijgRoi",
-                "mode": "turnstile",
-            },
-        )
-        print(resp2.json())
-
-if __name__ == "__main__":
-    asyncio.run(main())

cache/cache.json

@@ -1,10 +0,0 @@
-{
-  "{\"domain\":\"https://v2links.org\",\"mode\":\"iuam\"}": {
-    "timestamp": 1758616160392,
-    "value": {
-      "cf_clearance": "qqs5f4MpFMgA0v78Qmh_HYDWoKhbwqlQ57bTW5KeIr8-1758616161-1.2.1.1-D5PdpmheHl.26ssIRKQBsXzPtPPkSXntEZ_H9FUJVt7MMTS_BEE8iH.E48MDzKtFBLwZqRYxE_1GLo1gj3ChXrwatOGEJcmGRUwavy2qvGgUPizn7qufd.sW0ULfhaRO7Gz_H_eO1TU3iEqCzltEUDNk0SviKRFkF8ozbvJ91MW_qmO.qrjQorbu_jxcgJv5BHs6rTNOitWtVDAmYMDukASq0viHXIUAIvTM.LIfQ88",
-      "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
-      "elapsed_time": 5.028
-    }
-  }
-}

docs/swagger.js

@@ -0,0 +1,1098 @@
+const DOMAIN = process.env.DOMAIN;
+
+const swaggerDocument = {
+    openapi: "3.0.0",
+    info: {
+        title: "YouTube & Facebook Downloader & File Upload API",
+        version: "2.0.0",
+        description: "API untuk mengunduh video YouTube, Facebook, TikTok, Instagram sebagai MP3 atau MP4, mengupload file, dan bypass Cloudflare protection dengan session management"
+    },
+    servers: [
+        {
+            url: DOMAIN,
+            description: "Main Server"
+        }
+    ],
+    paths: {
+        "/api/download": {
+            get: {
+                summary: "Unduh video YouTube",
+                description: "Mengunduh video YouTube dan menyimpannya ke server, dengan opsi upload otomatis",
+                parameters: [
+                    {
+                        name: "url",
+                        in: "query",
+                        required: true,
+                        schema: { 
+                            type: "string" 
+                        },
+                        description: "URL video YouTube atau kata kunci"
+                    },
+                    {
+                        name: "format",
+                        in: "query",
+                        required: false,
+                        schema: {
+                            type: "string",
+                            enum: ["mp3", "360p", "720p", "1080p"],
+                            default: "360p"
+                        },
+                        description: "Format (mp3, 360p, 720p, 1080p)"
+                    },
+                    {
+                        name: "upload",
+                        in: "query",
+                        required: false,
+                        schema: {
+                            type: "string",
+                            enum: ["true", "false"],
+                            default: "false"
+                        },
+                        description: "Jika 'true', file akan diupload otomatis ke server eksternal setelah didownload"
+                    }
+                ],
+                responses: {
+                    "200": {
+                        description: "Berhasil",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        title: { 
+                                            type: "string",
+                                            example: "Judul Video YouTube" 
+                                        },
+                                        format: { 
+                                            type: "string",
+                                            example: "mp3" 
+                                        },
+                                        downloadURL: { 
+                                            type: "string",
+                                            example: "https://example.com/downloads/video.mp3" 
+                                        },
+                                        filename: { 
+                                            type: "string",
+                                            example: "video.mp3" 
+                                        },
+                                        upload: { 
+                                            type: "object",
+                                            properties: {
+                                                status: { 
+                                                    type: "boolean",
+                                                    example: true 
+                                                },
+                                                path: { 
+                                                    type: "string",
+                                                    example: "https://c.termai.cc/mp3/abc123" 
+                                                },
+                                                mimetype: { 
+                                                    type: "string",
+                                                    example: "audio/mpeg" 
+                                                },
+                                                size: { 
+                                                    type: "number",
+                                                    example: 5123456 
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "400": { 
+                        description: "Bad Request - Parameter tidak valid" 
+                    },
+                    "500": { 
+                        description: "Internal Server Error - Terjadi kesalahan server" 
+                    }
+                }
+            }
+        },
+        "/api/fb-download": {
+            get: {
+                summary: "Unduh video Facebook",
+                description: "Mengunduh video Facebook dalam kualitas tertentu dan menyimpannya ke server, dengan opsi upload otomatis",
+                parameters: [
+                    {
+                        name: "url",
+                        in: "query",
+                        required: true,
+                        schema: { 
+                            type: "string" 
+                        },
+                        description: "URL video Facebook"
+                    },
+                    {
+                        name: "quality",
+                        in: "query",
+                        required: false,
+                        schema: {
+                            type: "string",
+                            enum: ["720p(HD)", "360p(SD)", "Mp3"],
+                            default: "720p(HD)"
+                        },
+                        description: "Kualitas video (720p(HD), 360p(SD), Mp3)"
+                    },
+                    {
+                        name: "upload",
+                        in: "query",
+                        required: false,
+                        schema: {
+                            type: "string",
+                            enum: ["true", "false"],
+                            default: "false"
+                        },
+                        description: "Jika 'true', file akan diupload otomatis ke server eksternal setelah didownload"
+                    }
+                ],
+                responses: {
+                    "200": {
+                        description: "Berhasil",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        title: { 
+                                            type: "string",
+                                            example: "Judul Video Facebook" 
+                                        },
+                                        thumbnail: { 
+                                            type: "string",
+                                            example: "https://example.com/thumbnail.jpg" 
+                                        },
+                                        selectedQuality: { 
+                                            type: "string",
+                                            example: "720p(HD)" 
+                                        },
+                                        type: { 
+                                            type: "string",
+                                            example: "video" 
+                                        },
+                                        downloadURL: { 
+                                            type: "string",
+                                            example: "https://example.com/downloads/video_720p(HD).mp4" 
+                                        },
+                                        filename: { 
+                                            type: "string",
+                                            example: "video_720p(HD).mp4" 
+                                        },
+                                        size: { 
+                                            type: "number",
+                                            example: 15123456 
+                                        },
+                                        upload: { 
+                                            type: "object",
+                                            properties: {
+                                                status: { 
+                                                    type: "boolean",
+                                                    example: true 
+                                                },
+                                                path: { 
+                                                    type: "string",
+                                                    example: "https://c.termai.cc/mp4/abc123" 
+                                                },
+                                                mimetype: { 
+                                                    type: "string",
+                                                    example: "video/mp4" 
+                                                },
+                                                size: { 
+                                                    type: "number",
+                                                    example: 15123456 
+                                                }
+                                            }
+                                        },
+                                        availableQualities: {
+                                            type: "array",
+                                            items: {
+                                                type: "object",
+                                                properties: {
+                                                    quality: {
+                                                        type: "string",
+                                                        example: "720p(HD)"
+                                                    },
+                                                    type: {
+                                                        type: "string",
+                                                        example: "video"
+                                                    },
+                                                    url: {
+                                                        type: "string",
+                                                        example: "https://example.com/api/fb-download?url=...&quality=720p(HD)"
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "400": { 
+                        description: "Bad Request - Parameter tidak valid" 
+                    },
+                    "500": { 
+                        description: "Internal Server Error - Terjadi kesalahan server" 
+                    }
+                }
+            }
+        },
+        "/api/tiktok": {
+            get: {
+                summary: "Unduh video TikTok",
+                description: "Mengunduh video atau slide TikTok dan menyimpannya ke server",
+                parameters: [
+                    {
+                        name: "url",
+                        in: "query",
+                        required: true,
+                        schema: { 
+                            type: "string" 
+                        },
+                        description: "URL video TikTok"
+                    }
+                ],
+                responses: {
+                    "200": {
+                        description: "Berhasil",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { 
+                                            type: "boolean",
+                                            example: true 
+                                        },
+                                        type: { 
+                                            type: "string",
+                                            example: "video" 
+                                        },
+                                        description: { 
+                                            type: "string",
+                                            example: "Deskripsi video TikTok" 
+                                        },
+                                        author: { 
+                                            type: "object" 
+                                        },
+                                        stats: { 
+                                            type: "object" 
+                                        },
+                                        downloadInfo: { 
+                                            type: "object",
+                                            properties: {
+                                                download_url: {
+                                                    type: "string",
+                                                    example: "https://example.com/download/tiktok_folder/video.mp4"
+                                                },
+                                                filename: {
+                                                    type: "string",
+                                                    example: "video.mp4"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "400": { 
+                        description: "Bad Request - Parameter tidak valid" 
+                    },
+                    "500": { 
+                        description: "Internal Server Error - Terjadi kesalahan server" 
+                    }
+                }
+            }
+        },
+        "/api/instagram": {
+            get: {
+                summary: "Unduh konten Instagram",
+                description: "Mengunduh foto, video, atau reel dari Instagram",
+                parameters: [
+                    {
+                        name: "url",
+                        in: "query",
+                        required: true,
+                        schema: { 
+                            type: "string" 
+                        },
+                        description: "URL post/reel Instagram"
+                    }
+                ],
+                responses: {
+                    "200": {
+                        description: "Berhasil",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { 
+                                            type: "boolean",
+                                            example: true 
+                                        },
+                                        type: { 
+                                            type: "string",
+                                            example: "post" 
+                                        },
+                                        title: { 
+                                            type: "string",
+                                            example: "Judul post Instagram" 
+                                        },
+                                        likes: { 
+                                            type: "string",
+                                            example: "1500" 
+                                        },
+                                        comments: { 
+                                            type: "string",
+                                            example: "250" 
+                                        },
+                                        accountName: { 
+                                            type: "string",
+                                            example: "username" 
+                                        },
+                                        konten: {
+                                            type: "array",
+                                            items: {
+                                                type: "object",
+                                                properties: {
+                                                    type: {
+                                                        type: "string",
+                                                        example: "video"
+                                                    },
+                                                    url: {
+                                                        type: "string",
+                                                        example: "https://example.com/video.mp4"
+                                                    },
+                                                    thumbnail: {
+                                                        type: "string",
+                                                        example: "https://example.com/thumbnail.jpg"
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "400": { 
+                        description: "Bad Request - Parameter tidak valid" 
+                    },
+                    "500": { 
+                        description: "Internal Server Error - Terjadi kesalahan server" 
+                    }
+                }
+            }
+        },
+
+        // ============================
+        // BYCF CLOUDFLARE BYPASS APIs
+        // ============================
+
+        "/api/cf/waf-session": {
+            get: {
+                summary: "Get WAF Session (GET)",
+                description: "Mendapatkan WAF session untuk bypass Cloudflare protection - GET method",
+                parameters: [
+                    {
+                        name: "url",
+                        in: "query",
+                        required: true,
+                        schema: { 
+                            type: "string" 
+                        },
+                        description: "URL target yang diproteksi Cloudflare"
+                    },
+                    {
+                        name: "proxy",
+                        in: "query",
+                        required: false,
+                        schema: {
+                            type: "string"
+                        },
+                        description: "Proxy format: host:port"
+                    }
+                ],
+                responses: {
+                    "200": {
+                        description: "Berhasil",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { 
+                                            type: "boolean",
+                                            example: true 
+                                        },
+                                        url: { 
+                                            type: "string",
+                                            example: "https://example.com" 
+                                        },
+                                        cookies: { 
+                                            type: "object",
+                                            example: {"cf_clearance": "abc123", "__cflb": "xyz456"} 
+                                        },
+                                        userAgent: { 
+                                            type: "string",
+                                            example: "Mozilla/5.0..." 
+                                        },
+                                        headers: { 
+                                            type: "object" 
+                                        },
+                                        timestamp: { 
+                                            type: "string",
+                                            example: "2024-01-01T00:00:00.000Z" 
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            post: {
+                summary: "Create WAF Session dengan Cookie Lama (POST)",
+                description: "Membuat WAF session baru dengan input cookie lama untuk menghasilkan cookie baru",
+                requestBody: {
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                required: ["url"],
+                                properties: {
+                                    url: {
+                                        type: "string",
+                                        example: "https://target.com",
+                                        description: "URL target yang diproteksi Cloudflare"
+                                    },
+                                    cookies: {
+                                        type: "object",
+                                        example: {"old_cookie": "value123", "session_id": "abc456"},
+                                        description: "Cookie lama yang akan digunakan untuk membuat session baru"
+                                    },
+                                    proxy: {
+                                        type: "string",
+                                        example: "127.0.0.1:8080",
+                                        description: "Proxy format: host:port"
+                                    },
+                                    headers: {
+                                        type: "object",
+                                        description: "Custom headers tambahan"
+                                    },
+                                    userAgent: {
+                                        type: "string",
+                                        description: "Custom User-Agent"
+                                    },
+                                    sessionId: {
+                                        type: "string",
+                                        description: "Session ID khusus (opsional)"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                responses: {
+                    "200": {
+                        description: "Berhasil membuat session dengan cookie baru",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { 
+                                            type: "boolean",
+                                            example: true 
+                                        },
+                                        url: { 
+                                            type: "string",
+                                            example: "https://target.com" 
+                                        },
+                                        sessionId: { 
+                                            type: "string",
+                                            example: "session_123456789" 
+                                        },
+                                        oldCookies: { 
+                                            type: "object",
+                                            example: {"old_cookie": "value123"} 
+                                        },
+                                        newCookies: { 
+                                            type: "object",
+                                            example: {"cf_clearance": "new_value", "__cflb": "new_value2"} 
+                                        },
+                                        userAgent: { 
+                                            type: "string",
+                                            example: "Mozilla/5.0..." 
+                                        },
+                                        headers: { 
+                                            type: "object" 
+                                        },
+                                        sessionData: {
+                                            type: "object",
+                                            properties: {
+                                                id: { type: "string" },
+                                                createdAt: { type: "string" },
+                                                expiresAt: { type: "string" },
+                                                usageCount: { type: "number" }
+                                            }
+                                        },
+                                        timestamp: { 
+                                            type: "string",
+                                            example: "2024-01-01T00:00:00.000Z" 
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+
+        "/api/cf/waf-session-with-host": {
+            post: {
+                summary: "Create WAF Session dengan Host Khusus",
+                description: "Membuat WAF session dengan host header khusus dan cookie lama",
+                requestBody: {
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                required: ["url", "host"],
+                                properties: {
+                                    url: {
+                                        type: "string",
+                                        example: "https://target.com",
+                                        description: "URL target"
+                                    },
+                                    host: {
+                                        type: "string",
+                                        example: "api.target.com",
+                                        description: "Host header khusus"
+                                    },
+                                    cookies: {
+                                        type: "object",
+                                        example: {"old_cookie": "value123"},
+                                        description: "Cookie lama"
+                                    },
+                                    proxy: {
+                                        type: "string",
+                                        example: "127.0.0.1:8080",
+                                        description: "Proxy format: host:port"
+                                    },
+                                    userAgent: {
+                                        type: "string",
+                                        description: "Custom User-Agent"
+                                    },
+                                    sessionId: {
+                                        type: "string",
+                                        description: "Session ID khusus"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                responses: {
+                    "200": {
+                        description: "Berhasil",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { type: "boolean", example: true },
+                                        url: { type: "string" },
+                                        host: { type: "string" },
+                                        sessionId: { type: "string" },
+                                        oldCookies: { type: "object" },
+                                        newCookies: { type: "object" },
+                                        userAgent: { type: "string" },
+                                        headers: { type: "object" },
+                                        sessionData: { type: "object" },
+                                        timestamp: { type: "string" }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+
+        "/api/cf/renew-session": {
+            post: {
+                summary: "Renew Session",
+                description: "Memperbarui session yang sudah ada dengan cookie lama untuk menghasilkan cookie baru",
+                requestBody: {
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                required: ["sessionId"],
+                                properties: {
+                                    sessionId: {
+                                        type: "string",
+                                        example: "session_123456789",
+                                        description: "Session ID yang akan diperbarui"
+                                    },
+                                    url: {
+                                        type: "string",
+                                        description: "URL target (opsional, default: https://www.example.com)"
+                                    },
+                                    proxy: {
+                                        type: "string",
+                                        description: "Proxy format: host:port"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                responses: {
+                    "200": {
+                        description: "Berhasil memperbarui session",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { type: "boolean", example: true },
+                                        sessionId: { type: "string" },
+                                        oldCookies: { type: "object" },
+                                        newCookies: { type: "object" },
+                                        userAgent: { type: "string" },
+                                        headers: { type: "object" },
+                                        sessionData: { type: "object" },
+                                        timestamp: { type: "string" }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+
+        "/api/cf/session/{sessionId}": {
+            get: {
+                summary: "Get Session by ID",
+                description: "Mendapatkan informasi session berdasarkan ID",
+                parameters: [
+                    {
+                        name: "sessionId",
+                        in: "path",
+                        required: true,
+                        schema: { type: "string" },
+                        description: "Session ID"
+                    }
+                ],
+                responses: {
+                    "200": {
+                        description: "Berhasil",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { type: "boolean", example: true },
+                                        sessionId: { type: "string" },
+                                        cookies: { type: "object" },
+                                        userAgent: { type: "string" },
+                                        headers: { type: "object" },
+                                        sessionData: { type: "object" },
+                                        timestamp: { type: "string" }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            delete: {
+                summary: "Delete Session",
+                description: "Menghapus session berdasarkan ID",
+                parameters: [
+                    {
+                        name: "sessionId",
+                        in: "path",
+                        required: true,
+                        schema: { type: "string" },
+                        description: "Session ID yang akan dihapus"
+                    }
+                ],
+                responses: {
+                    "200": {
+                        description: "Berhasil menghapus session",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { type: "boolean", example: true },
+                                        message: { type: "string" },
+                                        sessionId: { type: "string" },
+                                        timestamp: { type: "string" }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+
+        "/api/cf/sessions": {
+            get: {
+                summary: "Get All Sessions",
+                description: "Mendapatkan daftar semua session yang aktif",
+                responses: {
+                    "200": {
+                        description: "Berhasil",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { type: "boolean", example: true },
+                                        sessions: { 
+                                            type: "array",
+                                            items: {
+                                                type: "object",
+                                                properties: {
+                                                    id: { type: "string" },
+                                                    cookies: { type: "object" },
+                                                    userAgent: { type: "string" },
+                                                    createdAt: { type: "string" },
+                                                    lastUsed: { type: "string" },
+                                                    expiresAt: { type: "string" },
+                                                    usageCount: { type: "number" }
+                                                }
+                                            }
+                                        },
+                                        total: { type: "number" },
+                                        timestamp: { type: "string" }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+
+        "/api/cf/turnstile": {
+            get: {
+                summary: "Solve Turnstile CAPTCHA",
+                description: "Menyelesaikan Cloudflare Turnstile CAPTCHA",
+                parameters: [
+                    {
+                        name: "url",
+                        in: "query",
+                        required: true,
+                        schema: { 
+                            type: "string" 
+                        },
+                        description: "URL target yang memiliki Turnstile"
+                    },
+                    {
+                        name: "sitekey",
+                        in: "query",
+                        required: true,
+                        schema: {
+                            type: "string"
+                        },
+                        description: "Sitekey Turnstile"
+                    },
+                    {
+                        name: "proxy",
+                        in: "query",
+                        required: false,
+                        schema: {
+                            type: "string"
+                        },
+                        description: "Proxy format: host:port"
+                    }
+                ],
+                responses: {
+                    "200": {
+                        description: "Berhasil",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { 
+                                            type: "boolean",
+                                            example: true 
+                                        },
+                                        url: { 
+                                            type: "string",
+                                            example: "https://example.com" 
+                                        },
+                                        sitekey: { 
+                                            type: "string",
+                                            example: "0x4AAAAAAABBBBB" 
+                                        },
+                                        turnstileToken: { 
+                                            type: "string",
+                                            example: "0.xabc123def456" 
+                                        },
+                                        timestamp: { 
+                                            type: "string",
+                                            example: "2024-01-01T00:00:00.000Z" 
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+
+        "/api/cf/autofaucet": {
+            get: {
+                summary: "Autofaucet Bypass",
+                description: "Bypass Cloudflare WAF dan Turnstile untuk autofaucet.org",
+                parameters: [
+                    {
+                        name: "proxy",
+                        in: "query",
+                        required: false,
+                        schema: {
+                            type: "string"
+                        },
+                        description: "Proxy format: host:port"
+                    }
+                ],
+                responses: {
+                    "200": {
+                        description: "Berhasil",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { 
+                                            type: "boolean",
+                                            example: true 
+                                        },
+                                        url: { 
+                                            type: "string",
+                                            example: "https://autofaucet.org/earn/faucet" 
+                                        },
+                                        sitekey: { 
+                                            type: "string",
+                                            example: "0x4AAAAAAAeegevyhnJu7zGA" 
+                                        },
+                                        wafSession: { 
+                                            type: "object" 
+                                        },
+                                        turnstileToken: { 
+                                            type: "string",
+                                            example: "0.xabc123def456" 
+                                        },
+                                        timestamp: { 
+                                            type: "string",
+                                            example: "2024-01-01T00:00:00.000Z" 
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+
+        "/api/cf/stats": {
+            get: {
+                summary: "Get BYCF Stats",
+                description: "Mendapatkan statistik penggunaan bycf",
+                responses: {
+                    "200": {
+                        description: "Berhasil",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { 
+                                            type: "boolean",
+                                            example: true 
+                                        },
+                                        stats: { 
+                                            type: "object" 
+                                        },
+                                        timestamp: { 
+                                            type: "string",
+                                            example: "2024-01-01T00:00:00.000Z" 
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+
+        // ============================
+        // UPLOAD APIs
+        // ============================
+
+        "/api/upload": {
+            post: {
+                summary: "Upload file (Form Data)",
+                description: "Mengupload file ke server eksternal menggunakan form-data",
+                requestBody: {
+                    required: true,
+                    content: {
+                        "multipart/form-data": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    file: {
+                                        type: "string",
+                                        format: "binary",
+                                        description: "File yang akan diupload"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                responses: {
+                    "200": {
+                        description: "File berhasil diupload",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        status: { 
+                                            type: "boolean",
+                                            example: true 
+                                        },
+                                        path: { 
+                                            type: "string",
+                                            example: "https://c.termai.cc/jpeg/T0鳍p" 
+                                        },
+                                        mimetype: { 
+                                            type: "string",
+                                            example: "image/jpeg" 
+                                        },
+                                        size: { 
+                                            type: "number",
+                                            example: 171062 
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "400": { 
+                        description: "Bad Request - Tidak ada file yang diunggah" 
+                    },
+                    "500": { 
+                        description: "Internal Server Error - Terjadi kesalahan server" 
+                    }
+                }
+            }
+        },
+
+        "/api/upload-base64": {
+            post: {
+                summary: "Upload file (Base64)",
+                description: "Mengupload file ke server eksternal menggunakan base64",
+                requestBody: {
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                required: ["file"],
+                                properties: {
+                                    file: {
+                                        type: "string",
+                                        description: "File dalam format base64"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                responses: {
+                    "200": {
+                        description: "File berhasil diupload",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        status: { type: "boolean", example: true },
+                                        path: { type: "string" },
+                                        mimetype: { type: "string" },
+                                        size: { type: "number" }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+
+        "/api/upload-local": {
+            post: {
+                summary: "Upload file dari local",
+                description: "Mengupload file yang sudah ada di server local ke server eksternal",
+                requestBody: {
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                required: ["filename"],
+                                properties: {
+                                    filename: {
+                                        type: "string",
+                                        description: "Nama file yang ada di folder downloads"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                responses: {
+                    "200": {
+                        description: "File berhasil diupload",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        status: { type: "boolean", example: true },
+                                        path: { type: "string" },
+                                        mimetype: { type: "string" },
+                                        size: { type: "number" }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+};
+
+module.exports = swaggerDocument;

endpoints/cloudflare.js

@@ -1,79 +0,0 @@
-async function cloudflare(data, page) {
-  return new Promise(async (resolve, reject) => {
-    if (!data.domain) return reject(new Error("Missing domain parameter"))
-
-    const startTime = Date.now()
-    let isResolved = false
-    let userAgent = null
-
-    const cl = setTimeout(() => {
-      if (!isResolved) {
-        isResolved = true
-        const elapsedTime = (Date.now() - startTime) / 1000
-        resolve({
-          cf_clearance: null,
-          user_agent: userAgent,
-          elapsed_time: elapsedTime,
-        })
-      }
-    }, 20000)
-
-    try {
-      if (data.proxy?.username && data.proxy?.password) {
-        await page.authenticate({
-          username: data.proxy.username,
-          password: data.proxy.password,
-        })
-      }
-
-      page.removeAllListeners("request")
-      page.removeAllListeners("response")
-      await page.setRequestInterception(true)
-
-      page.on("request", async (req) => {
-        try {
-          await req.continue()
-        } catch (_) {}
-      })
-
-      page.on("response", async (res) => {
-        try {
-          const url = res.url()
-          if (url.includes("/cdn-cgi/challenge-platform/")) {
-            const headers = res.headers()
-            if (headers["set-cookie"]) {
-              const match = headers["set-cookie"].match(/cf_clearance=([^;]+)/)
-              if (match) {
-                const cf_clearance = match[1]
-                const userAgent = (await res.request().headers())["user-agent"]
-                const elapsedTime = (Date.now() - startTime) / 1000
-
-                if (!isResolved) {
-                  isResolved = true
-                  clearTimeout(cl)
-
-                  resolve({
-                    cf_clearance,
-                    user_agent: userAgent,
-                    elapsed_time: elapsedTime,
-                  })
-                }
-              }
-            }
-          }
-        } catch (_) {}
-      })
-
-      await page.goto(data.domain, { waitUntil: "domcontentloaded" })
-      userAgent = await page.evaluate(() => navigator.userAgent)
-    } catch (err) {
-      if (!isResolved) {
-        isResolved = true
-        clearTimeout(cl)
-        reject(err)
-      }
-    }
-  })
-}
-
-module.exports = cloudflare

endpoints/turnstile.js

@@ -1,72 +0,0 @@
-async function turnstile({ domain, proxy, siteKey }, page) {
-  if (!domain) throw new Error("Missing domain")
-  if (!siteKey) throw new Error("Missing siteKey")
-
-  const timeout = global.timeOut || 60000
-  let resolved = false
-  let timeoutId
-
-  try {
-    if (proxy?.username && proxy?.password) {
-      await page.authenticate({
-        username: proxy.username,
-        password: proxy.password,
-      }).catch(() => {})
-    }
-
-    const htmlContent = `
-      <!DOCTYPE html>
-      <html><body>
-        <div class="turnstile"></div>
-        <script src="https://challenges.cloudflare.com/turnstile/v0/api.js?onload=onloadTurnstileCallback" defer></script>
-        <script>
-          window.onloadTurnstileCallback = function() {
-            turnstile.render('.turnstile', {
-              sitekey: '${siteKey}',
-              callback: function(token) {
-                window.turnstileToken = token
-              }
-            })
-          }
-        </script>
-      </body></html>
-    `
-
-    await page.setRequestInterception(true)
-    page.removeAllListeners("request")
-    
-    page.on("request", async (request) => {
-      const url = request.url().split('?')[0]
-      if ([domain, domain + "/"].includes(url) && request.resourceType() === "document") {
-        await request.respond({
-          status: 200,
-          contentType: "text/html",
-          body: htmlContent,
-        })
-      } else {
-        await request.continue()
-      }
-    })
-
-    timeoutId = setTimeout(() => {
-      if (!resolved) throw new Error("Timeout")
-    }, timeout)
-
-    await page.goto(domain, { waitUntil: "domcontentloaded", timeout: 30000 })
-
-    await page.waitForFunction(() => window.turnstileToken, { timeout })
-    const token = await page.evaluate(() => window.turnstileToken)
-
-    resolved = true
-    clearTimeout(timeoutId)
-
-    if (!token) throw new Error("No token received")
-    return token
-
-  } catch (e) {
-    clearTimeout(timeoutId)
-    throw e
-  }
-}
-
-module.exports = turnstile

index.js

@@ -1,154 +1,1284 @@
-const express = require('express')
-const { connect } = require("puppeteer-real-browser")
-const fs = require("fs")
-const path = require("path")
+const express = require('express');
+const cors = require('cors');
+const path = require('path');
+const fs = require('fs');
+const swaggerUi = require('swagger-ui-express');
+const fetch = (...args) => import('node-fetch').then(({ default: fetch }) => fetch(...args));
+const { pipeline } = require('stream');
+const { promisify } = require('util');
+const axios = require("axios");
+const FormData = require("form-data");
+const fileType = require('file-type');
+const streamPipeline = promisify(pipeline);
+const multer = require('multer');
+const cheerio = require('cheerio');
+const bycf = require('bycf');
 
-const app = express()
-const port = process.env.PORT || 7860
-const authToken = process.env.authToken || null
+const app = express();
+const PORT = 7860;
+const DOMAIN = process.env.DOMAIN || `https://rezaharis-cf.hf.space`;
 
-global.browserLimit = Number(process.env.browserLimit) || 20
-global.timeOut = Number(process.env.timeOut) || 60000
+const downloadsDir = path.join(__dirname, 'downloads');
+if (!fs.existsSync(downloadsDir)) fs.mkdirSync(downloadsDir, { recursive: true });
 
-const CACHE_DIR = path.join(__dirname, "cache")
-const CACHE_FILE = path.join(CACHE_DIR, "cache.json")
-const CACHE_TTL = 5 * 60 * 1000
+const upload = multer({
+  storage: multer.memoryStorage(),
+  limits: {
+    fileSize: 50 * 1024 * 1024,
+  },
+});
 
-function loadCache() {
-  if (!fs.existsSync(CACHE_FILE)) return {}
+app.use(cors());
+app.use(express.json({ limit: '50mb' }));
+app.use(express.urlencoded({ extended: true, limit: '50mb' }));
+app.use(express.static('public'));
+app.use('/downloads', express.static(downloadsDir));
+
+const UPLOAD_KEY = process.env.UPLOAD_KEY || "AIzaBj7z2z3xBjsk";
+const UPLOAD_DOMAIN = process.env.UPLOAD_DOMAIN || 'https://c.termai.cc';
+
+// Session storage untuk menyimpan cookie sessions
+const sessionStorage = new Map();
+
+const delay = (ms, reason = '') => {
+  console.log(`⏳ Delay ${ms}ms ${reason ? `- ${reason}` : ''}`);
+  return new Promise(resolve => setTimeout(resolve, ms));
+};
+
+const getRandomUserAgent = () => {
+  const agents = [
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/121.0',
+    'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1'
+  ];
+  return agents[Math.floor(Math.random() * agents.length)];
+};
+
+const uploadFile = async (file) => {
   try {
-    return JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"))
-  } catch {
-    return {}
+    console.log('📤 Memulai proses upload file...');
+    
+    let fileTypeResult;
+    if (typeof fileType.fromBuffer === 'function') {
+      fileTypeResult = await fileType.fromBuffer(file);
+    } else if (typeof fileType.fileTypeFromBuffer === 'function') {
+      fileTypeResult = await fileType.fileTypeFromBuffer(file);
+    } else {
+      throw new Error('Tidak dapat mendeteksi tipe file');
+    }
+
+    if (!fileTypeResult) {
+      throw new Error('Tipe file tidak dikenali');
+    }
+
+    console.log(`📄 Tipe file terdeteksi: ${fileTypeResult.ext}`);
+
+    const formData = new FormData();
+    formData.append('file', file, { 
+      filename: `file.${fileTypeResult.ext}`
+    });
+
+    console.log('🔄 Mengirim file ke server upload...');
+    const response = await axios.post(
+      `${UPLOAD_DOMAIN}/api/upload?key=${UPLOAD_KEY}`, 
+      formData, 
+      {
+        headers: {
+          ...formData.getHeaders(),
+        },
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+    );
+
+    console.log('✅ File berhasil diupload');
+    return response.data;
+  } catch (error) {
+    console.error('❌ Error uploading file:', error.response?.data || error.message);
+    throw new Error(error.response?.data?.message || 'Gagal mengupload file');
   }
-}
+};
 
-function saveCache(cache) {
+async function getFacebookVideoData(fbUrl) {
   try {
-    if (!fs.existsSync(CACHE_DIR)) fs.mkdirSync(CACHE_DIR, { recursive: true })
-    fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2))
-  } catch {}
-}
+    console.log(`🔍 Mencari data video Facebook: ${fbUrl}`);
+    
+    const encodedUrl = encodeURIComponent(fbUrl);
+    const postData = `id=${encodedUrl}&locale=id`;
+    
+    const response = await axios.post('https://getmyfb.com/process', postData, {
+      headers: {
+        'HX-Request': 'true',
+        'HX-Trigger': 'form',
+        'HX-Target': 'target',
+        'HX-Current-URL': 'https://getmyfb.com/id',
+        'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+        'User-Agent': getRandomUserAgent(),
+        'Referer': 'https://getmyfb.com/id'
+      }
+    });
 
-function readCache(key) {
-  const cache = loadCache()
-  const entry = cache[key]
-  if (entry && Date.now() - entry.timestamp < CACHE_TTL) return entry.value
-  return null
+    console.log('✅ Berhasil mendapatkan response dari getmyfb.com');
+    const $ = cheerio.load(response.data);
+    
+    const result = {
+      title: $('.results-item-text').text().trim() || 'Facebook Video',
+      thumbnail: $('.results-item-image').attr('src'),
+      downloads: []
+    };
+    
+    console.log(`📝 Judul video: ${result.title}`);
+    
+    $('.results-list-item').each((index, element) => {
+      const item = $(element);
+      const qualityText = item.contents().first().text().trim();
+      const link = item.find('a');
+      
+      let quality = qualityText;
+      if (qualityText.includes('HD') || qualityText.includes('720')) {
+        quality = '720p(HD)';
+      } else if (qualityText.includes('SD') || qualityText.includes('360')) {
+        quality = '360p(SD)';
+      } else if (qualityText.toLowerCase().includes('audio') || qualityText.toLowerCase().includes('mp3')) {
+        quality = 'Mp3';
+      }
+      
+      if (link.attr('href')) {
+        result.downloads.push({
+          quality: quality,
+          url: link.attr('href'),
+          type: link.hasClass('mp3') ? 'audio' : 'video'
+        });
+        console.log(`🎯 Kualitas ditemukan: ${quality} - ${link.attr('href')}`);
+      }
+    });
+    
+    console.log(`📊 Total kualitas tersedia: ${result.downloads.length}`);
+    return result;
+    
+  } catch (error) {
+    console.error('❌ Error getting Facebook video data:', error.message);
+    throw new Error('Gagal mendapatkan data video Facebook');
+  }
 }
 
-function writeCache(key, value) {
-  const cache = loadCache()
-  cache[key] = { timestamp: Date.now(), value }
-  saveCache(cache)
+async function downloadAndSaveFile(url, filename, quality) {
+  try {
+    const filePath = path.join(downloadsDir, filename);
+    
+    console.log(`⬇️  Memulai download dari: ${url}`);
+    console.log(`📁 Menyimpan sebagai: ${filename}`);
+    
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    
+    if (!response.body) {
+      throw new Error('Tidak ada body response');
+    }
+    
+    const fileStream = fs.createWriteStream(filePath);
+    await streamPipeline(response.body, fileStream);
+    
+    console.log('⏳ Menunggu file tersimpan...');
+    await delay(500, 'Memastikan file tersimpan sempurna');
+    
+    if (!fs.existsSync(filePath)) {
+      throw new Error('File tidak berhasil dibuat');
+    }
+    
+    const stats = fs.statSync(filePath);
+    if (stats.size === 0) {
+      fs.unlinkSync(filePath);
+      throw new Error('File berukuran 0 byte - download gagal');
+    }
+    
+    console.log(`✅ Download selesai: ${filename} (${(stats.size / 1024 / 1024).toFixed(2)} MB)`);
+    
+    return {
+      quality: quality,
+      filename: filename,
+      path: filePath,
+      downloadURL: `${DOMAIN}/downloads/${encodeURIComponent(filename)}`,
+      size: stats.size
+    };
+  } catch (error) {
+    const filePath = path.join(downloadsDir, filename);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+    }
+    console.error(`❌ Gagal mendownload file ${quality}: ${error.message}`);
+    throw new Error(`Gagal mendownload file ${quality}: ${error.message}`);
+  }
 }
 
-app.use(express.json())
-app.use(express.urlencoded({ extended: true }))
+const yt = {
+    get baseUrl() {
+        return { origin: 'https://ssvid.app' };
+    },
 
-// Root endpoint sederhana
-app.get('/', (req, res) => {
-  res.status(200).json({ 
-    message: 'Cloudflare Solver API',
-    port: port,
-    status: 'active'
-  })
-})
-
-async function createBrowser(proxyServer = null) {
-  const connectOptions = {
-    headless: true,
-    turnstile: true,
-    connectOption: { 
-      defaultViewport: null,
-      args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage']
-    }
-  }
-  
-  if (proxyServer) {
-    connectOptions.args = [...(connectOptions.connectOption.args || []), `--proxy-server=${proxyServer}`]
-  }
-  
-  const { browser } = await connect(connectOptions)
-  const page = (await browser.pages())[0] || await browser.newPage()
-
-  await page.setRequestInterception(true)
-  page.on('request', (req) => {
-    if (["image", "stylesheet", "font", "media"].includes(req.resourceType())) {
-      req.abort()
-    } else {
-      req.continue()
+    get baseHeaders() {
+        return {
+            'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
+            'origin': this.baseUrl.origin,
+            'referer': this.baseUrl.origin + '/youtube-to-mp3',
+            'User-Agent': getRandomUserAgent()
+        };
+    },
+
+    validateFormat(userFormat) {
+        const validFormat = ['mp3', '360p', '720p', '1080p'];
+        if (!validFormat.includes(userFormat)) {
+            console.error(`❌ Format tidak valid: ${userFormat}. Format tersedia: ${validFormat.join(', ')}`);
+            throw Error(`invalid format!. available formats: ${validFormat.join(', ')}`);
+        }
+        console.log(`✅ Format valid: ${userFormat}`);
+    },
+
+    handleFormat(userFormat, searchJson) {
+        this.validateFormat(userFormat);
+        let result;
+
+        if (userFormat === 'mp3') {
+            console.log('🎵 Mencari format MP3...');
+            result = searchJson.links?.mp3?.mp3128?.k;
+            if (!result) {
+                console.log('❌ MP3 tidak ditemukan, mencoba alternatif...');
+                const mp3Formats = searchJson.links?.mp3;
+                if (mp3Formats) {
+                    const availableMp3 = Object.keys(mp3Formats);
+                    console.log(`🎵 Format MP3 tersedia: ${availableMp3.join(', ')}`);
+                    result = mp3Formats[availableMp3[0]]?.k;
+                }
+            }
+        } else {
+            console.log(`🎥 Mencari format video: ${userFormat}`);
+            let selectedFormat;
+            const allFormats = Object.entries(searchJson.links.mp4);
+            const quality = allFormats
+                .map(v => v[1].q)
+                .filter(v => /\d+p/.test(v))
+                .map(v => parseInt(v))
+                .sort((a, b) => b - a)
+                .map(v => v + 'p');
+
+            console.log(`📊 Kualitas video tersedia: ${quality.join(', ')}`);
+
+            if (!quality.includes(userFormat)) {
+                selectedFormat = quality.includes('360p') ? '360p' : quality[0];
+                console.log(`⚠️  Format ${userFormat} tidak ada. Fallback ke ${selectedFormat}`);
+            } else {
+                selectedFormat = userFormat;
+            }
+
+            const find = allFormats.find(v => v[1].q == selectedFormat);
+            result = find?.[1]?.k;
+        }
+
+        if (!result) {
+            console.error('❌ Tidak ada hasil untuk format yang diminta');
+            throw Error(`${userFormat} gak ada cuy. aneh`);
+        }
+        
+        console.log(`✅ Format ${userFormat} ditemukan`);
+        return result;
+    },
+
+    async hit(path, payload) {
+        try {
+            console.log(`🌐 Request ke: ${path}`);
+            
+            await delay(3000 + Math.random() * 4000, `Request ke ${path}`);
+            
+            const body = new URLSearchParams(payload);
+            const opts = { 
+                headers: this.baseHeaders, 
+                body, 
+                method: 'POST' 
+            };
+            
+            const r = await fetch(`${this.baseUrl.origin}${path}`, opts);
+
+            if (!r.ok) {
+                console.error(`❌ HTTP Error: ${r.status} ${r.statusText}`);
+                throw Error(`${r.status} ${r.statusText}`);
+            }
+            
+            const j = await r.json();
+            console.log(`✅ Response berhasil dari: ${path}`);
+            return j;
+        } catch (e) {
+            console.error(`❌ Error pada request ${path}:`, e.message);
+            throw Error(`${path}\n${e.message}`);
+        }
+    },
+
+    async download(queryOrYtUrl, userFormat = 'mp3') {
+        console.log(`🚀 Memulai proses download YouTube: ${queryOrYtUrl}`);
+        console.log(`🎯 Format yang diminta: ${userFormat}`);
+        
+        this.validateFormat(userFormat);
+        
+        await delay(4000, 'Delay awal sebelum search');
+        
+        let search = await this.hit('/api/ajax/search?hl=en', {
+            query: queryOrYtUrl,
+            cf_token: "",
+            vt: "youtube"
+        });
+
+        console.log('🔍 Search result:', search.p);
+
+        if (search.p === 'search') {
+            console.log('🔎 Mode: Pencarian video');
+            if (!search?.items?.length) {
+                console.error('❌ Hasil pencarian kosong');
+                throw Error(`hasil pencarian ${queryOrYtUrl} tidak ada`);
+            }
+            
+            const { v, t } = search.items[0];
+            const videoUrl = 'https://www.youtube.com/watch?v=' + v;
+            console.log(`📹 Video ditemukan:\n   Judul: ${t}\n   URL: ${videoUrl}`);
+            
+            await delay(3000, 'Sebelum request detail video');
+            
+            search = await this.hit('/api/ajax/search?hl=en', {
+                query: videoUrl,
+                cf_token: "",
+                vt: "youtube"
+            });
+        } else {
+            console.log('📹 Mode: Direct video URL');
+        }
+
+        const vid = search.vid;
+        console.log(`🆔 Video ID: ${vid}`);
+
+        const k = this.handleFormat(userFormat, search);
+        console.log(`🔑 Download key: ${k}`);
+
+        console.log('🔄 Memulai proses convert...');
+        const convert = await this.hit('/api/ajax/convert', { k, vid });
+
+        console.log(`📊 Convert status: ${convert.c_status}`);
+
+        if (convert.c_status === 'CONVERTING') {
+            console.log('⏳ File sedang diproses, menunggu...');
+            let convert2;
+            
+            while (true) {
+                console.log(`🔄 Checking status...`);
+                
+                convert2 = await this.hit('/api/convert/check?hl=en', {
+                    vid,
+                    b_id: convert.b_id
+                });
+                
+                console.log(`📊 Status: ${convert2.c_status}`);
+                
+                if (convert2.c_status === 'CONVERTED') {
+                    console.log('✅ Convert selesai!');
+                    return convert2;
+                }
+                
+                await delay(5000, 'Menunggu proses convert');
+            }
+        } else {
+            console.log('✅ Convert langsung selesai');
+            return convert;
+        }
     }
-  })
+};
 
-  return { browser, page }
-}
+// ============================
+// BYCF CLOUDFLARE BYPASS APIs - ENHANCED
+// ============================
+
+// Session management functions
+const createSession = (sessionId, data) => {
+    const sessionData = {
+        id: sessionId,
+        cookies: data.cookies || {},
+        headers: data.headers || {},
+        userAgent: data.userAgent || getRandomUserAgent(),
+        createdAt: new Date().toISOString(),
+        lastUsed: new Date().toISOString(),
+        expiresAt: new Date(Date.now() + 30 * 60 * 1000).toISOString(), // 30 menit
+        usageCount: 0
+    };
+    sessionStorage.set(sessionId, sessionData);
+    return sessionData;
+};
 
-const turnstile = require('./endpoints/turnstile')
-const cloudflare = require('./endpoints/cloudflare')
+const getSession = (sessionId) => {
+    const session = sessionStorage.get(sessionId);
+    if (session) {
+        session.lastUsed = new Date().toISOString();
+        session.usageCount++;
+        sessionStorage.set(sessionId, session);
+    }
+    return session;
+};
 
-app.post('/cloudflare', async (req, res) => {
-  const data = req.body
-  
-  if (!data?.mode) return res.status(400).json({ message: 'Bad Request' })
-  if (authToken && data.authToken !== authToken) return res.status(401).json({ message: 'Unauthorized' })
-  if (global.browserLimit <= 0) return res.status(429).json({ message: 'Too Many Requests' })
+const updateSessionCookies = (sessionId, newCookies) => {
+    const session = getSession(sessionId);
+    if (session) {
+        session.cookies = { ...session.cookies, ...newCookies };
+        sessionStorage.set(sessionId, session);
+    }
+    return session;
+};
 
-  let cacheKey, cached
-  if (data.mode === "iuam") {
-    cacheKey = JSON.stringify(data)
-    cached = readCache(cacheKey)
-    if (cached) return res.status(200).json({ ...cached, cached: true })
+// POST endpoint untuk WAF Session dengan input cookie lama
+app.post('/api/cf/waf-session', async (req, res) => {
+  try {
+    const { url, proxy, cookies: oldCookies, headers: customHeaders, userAgent, sessionId } = req.body;
+    
+    if (!url) {
+      return res.status(400).json({ 
+        success: false, 
+        error: "Parameter 'url' diperlukan" 
+      });
+    }
+
+    console.log(`🛡️  Request WAF Session dengan cookie lama untuk: ${url}`);
+    console.log(`🍪 Cookie lama:`, oldCookies);
+
+    // Konfigurasi session dengan cookie lama
+    const sessionConfig = {
+      proxy: proxy || "host:port",
+      headers: customHeaders || {},
+      userAgent: userAgent || getRandomUserAgent()
+    };
+
+    // Jika ada cookie lama, tambahkan ke konfigurasi
+    if (oldCookies) {
+      sessionConfig.cookies = oldCookies;
+    }
+
+    const session = await bycf.shannz.wafSession(url, sessionConfig);
+
+    console.log('✅ WAF Session berhasil dibuat dengan cookie baru');
+    console.log(`🍪 Cookie baru:`, session.cookies);
+    
+    // Buat atau update session
+    const finalSessionId = sessionId || `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const sessionData = createSession(finalSessionId, {
+        cookies: session.cookies,
+        headers: session.headers,
+        userAgent: session.headers['User-Agent']
+    });
+    
+    res.json({
+      success: true,
+      url: url,
+      sessionId: finalSessionId,
+      oldCookies: oldCookies,
+      newCookies: session.cookies,
+      userAgent: session.headers['User-Agent'],
+      headers: session.headers,
+      sessionData: {
+        id: finalSessionId,
+        createdAt: sessionData.createdAt,
+        expiresAt: sessionData.expiresAt,
+        usageCount: sessionData.usageCount
+      },
+      timestamp: new Date().toISOString()
+    });
+
+  } catch (error) {
+    console.error('❌ Error creating WAF session with old cookies:', error.message);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message 
+    });
   }
+});
+
+// GET endpoint untuk WAF Session (backward compatibility)
+app.get('/api/cf/waf-session', async (req, res) => {
+  try {
+    const { url, proxy } = req.query;
+    
+    if (!url) {
+      return res.status(400).json({ 
+        success: false, 
+        error: "Parameter 'url' diperlukan" 
+      });
+    }
+
+    console.log(`🛡️  Request WAF Session untuk: ${url}`);
+
+    const session = await bycf.shannz.wafSession(
+      url,
+      proxy || "host:port"
+    );
 
-  global.browserLimit--
-  let browser = null
+    console.log('✅ WAF Session berhasil didapatkan');
+    
+    res.json({
+      success: true,
+      url: url,
+      cookies: session.cookies,
+      userAgent: session.headers['User-Agent'],
+      headers: session.headers,
+      timestamp: new Date().toISOString()
+    });
 
+  } catch (error) {
+    console.error('❌ Error getting WAF session:', error.message);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message 
+    });
+  }
+});
+
+// Endpoint untuk WAF Session dengan host khusus
+app.post('/api/cf/waf-session-with-host', async (req, res) => {
   try {
-    const proxyServer = data.proxy ? `${data.proxy.hostname}:${data.proxy.port}` : null
-    const { browser: br, page } = await createBrowser(proxyServer)
-    browser = br
+    const { url, host, cookies: oldCookies, proxy, userAgent, sessionId } = req.body;
+    
+    if (!url || !host) {
+      return res.status(400).json({ 
+        success: false, 
+        error: "Parameter 'url' dan 'host' diperlukan" 
+      });
+    }
+
+    console.log(`🛡️  Request WAF Session dengan host khusus: ${url}`);
+    console.log(`🌐 Host: ${host}`);
+    console.log(`🍪 Cookie lama:`, oldCookies);
+
+    // Konfigurasi session dengan host khusus
+    const sessionConfig = {
+      proxy: proxy || "host:port",
+      userAgent: userAgent || getRandomUserAgent(),
+      headers: {
+        'Host': host,
+        ...(oldCookies && { 'Cookie': Object.entries(oldCookies).map(([k, v]) => `${k}=${v}`).join('; ') })
+      }
+    };
+
+    // Jika ada cookie lama, tambahkan ke konfigurasi
+    if (oldCookies) {
+      sessionConfig.cookies = oldCookies;
+    }
+
+    const session = await bycf.shannz.wafSession(url, sessionConfig);
 
-    let result
-    switch (data.mode) {
-      case "turnstile":
-        result = await turnstile(data, page)
-          .then(token => ({ token }))
-          .catch(err => ({ code: 500, message: err.message }))
-        break
+    console.log('✅ WAF Session dengan host khusus berhasil dibuat');
+    console.log(`🍪 Cookie baru:`, session.cookies);
+    
+    // Buat atau update session
+    const finalSessionId = sessionId || `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const sessionData = createSession(finalSessionId, {
+        cookies: session.cookies,
+        headers: session.headers,
+        userAgent: session.headers['User-Agent']
+    });
+    
+    res.json({
+      success: true,
+      url: url,
+      host: host,
+      sessionId: finalSessionId,
+      oldCookies: oldCookies,
+      newCookies: session.cookies,
+      userAgent: session.headers['User-Agent'],
+      headers: session.headers,
+      sessionData: {
+        id: finalSessionId,
+        createdAt: sessionData.createdAt,
+        expiresAt: sessionData.expiresAt,
+        usageCount: sessionData.usageCount
+      },
+      timestamp: new Date().toISOString()
+    });
 
-      case "iuam":
-        result = await cloudflare(data, page)
-          .then(r => ({ ...r }))
-          .catch(err => ({ code: 500, message: err.message }))
+  } catch (error) {
+    console.error('❌ Error creating WAF session with custom host:', error.message);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message 
+    });
+  }
+});
 
-        if (!result.code) writeCache(cacheKey, result)
-        break
+// Endpoint untuk renew session dengan cookie lama
+app.post('/api/cf/renew-session', async (req, res) => {
+  try {
+    const { sessionId, url, proxy } = req.body;
+    
+    if (!sessionId) {
+      return res.status(400).json({ 
+        success: false, 
+        error: "Parameter 'sessionId' diperlukan" 
+      });
+    }
 
-      default:
-        result = { code: 400, message: 'Invalid mode' }
+    const existingSession = getSession(sessionId);
+    if (!existingSession) {
+      return res.status(404).json({ 
+        success: false, 
+        error: "Session tidak ditemukan" 
+      });
     }
 
-    res.status(result.code ?? 200).json(result)
+    console.log(`🔄 Renew session: ${sessionId}`);
+    console.log(`🍪 Cookie lama dari session:`, existingSession.cookies);
+
+    const sessionConfig = {
+      proxy: proxy || "host:port",
+      cookies: existingSession.cookies,
+      headers: existingSession.headers,
+      userAgent: existingSession.userAgent
+    };
+
+    const targetUrl = url || 'https://www.example.com';
+    const newSession = await bycf.shannz.wafSession(targetUrl, sessionConfig);
+
+    // Update session dengan cookie baru
+    const updatedSession = updateSessionCookies(sessionId, newSession.cookies);
+    
+    console.log('✅ Session berhasil di-renew dengan cookie baru');
+    
+    res.json({
+      success: true,
+      sessionId: sessionId,
+      oldCookies: existingSession.cookies,
+      newCookies: newSession.cookies,
+      userAgent: newSession.headers['User-Agent'],
+      headers: newSession.headers,
+      sessionData: {
+        id: sessionId,
+        createdAt: updatedSession.createdAt,
+        lastUsed: updatedSession.lastUsed,
+        expiresAt: updatedSession.expiresAt,
+        usageCount: updatedSession.usageCount
+      },
+      timestamp: new Date().toISOString()
+    });
+
+  } catch (error) {
+    console.error('❌ Error renewing session:', error.message);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message 
+    });
+  }
+});
+
+// Endpoint untuk mendapatkan session by ID
+app.get('/api/cf/session/:sessionId', async (req, res) => {
+  try {
+    const { sessionId } = req.params;
+    
+    const session = getSession(sessionId);
+    if (!session) {
+      return res.status(404).json({ 
+        success: false, 
+        error: "Session tidak ditemukan" 
+      });
+    }
+
+    console.log(`📋 Get session: ${sessionId}`);
+    
+    res.json({
+      success: true,
+      sessionId: sessionId,
+      cookies: session.cookies,
+      userAgent: session.userAgent,
+      headers: session.headers,
+      sessionData: {
+        id: session.id,
+        createdAt: session.createdAt,
+        lastUsed: session.lastUsed,
+        expiresAt: session.expiresAt,
+        usageCount: session.usageCount
+      },
+      timestamp: new Date().toISOString()
+    });
+
+  } catch (error) {
+    console.error('❌ Error getting session:', error.message);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message 
+    });
+  }
+});
+
+// Endpoint untuk menghapus session
+app.delete('/api/cf/session/:sessionId', async (req, res) => {
+  try {
+    const { sessionId } = req.params;
+    
+    const deleted = sessionStorage.delete(sessionId);
+    
+    if (!deleted) {
+      return res.status(404).json({ 
+        success: false, 
+        error: "Session tidak ditemukan" 
+      });
+    }
+
+    console.log(`🗑️  Delete session: ${sessionId}`);
+    
+    res.json({
+      success: true,
+      message: "Session berhasil dihapus",
+      sessionId: sessionId,
+      timestamp: new Date().toISOString()
+    });
+
+  } catch (error) {
+    console.error('❌ Error deleting session:', error.message);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message 
+    });
+  }
+});
+
+// Endpoint untuk mendapatkan semua sessions
+app.get('/api/cf/sessions', async (req, res) => {
+  try {
+    const sessions = Array.from(sessionStorage.entries()).map(([id, data]) => ({
+      id,
+      cookies: data.cookies,
+      userAgent: data.userAgent,
+      createdAt: data.createdAt,
+      lastUsed: data.lastUsed,
+      expiresAt: data.expiresAt,
+      usageCount: data.usageCount
+    }));
+
+    console.log(`📊 Get all sessions: ${sessions.length} sessions found`);
+    
+    res.json({
+      success: true,
+      sessions: sessions,
+      total: sessions.length,
+      timestamp: new Date().toISOString()
+    });
+
+  } catch (error) {
+    console.error('❌ Error getting sessions:', error.message);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message 
+    });
+  }
+});
+
+// Existing BYCF endpoints (tetap dipertahankan untuk backward compatibility)
+app.get('/api/cf/turnstile', async (req, res) => {
+  try {
+    const { url, sitekey, proxy } = req.query;
+    
+    if (!url || !sitekey) {
+      return res.status(400).json({ 
+        success: false, 
+        error: "Parameter 'url' dan 'sitekey' diperlukan" 
+      });
+    }
+
+    console.log(`🔄 Request Turnstile Token untuk: ${url}`);
+
+    const token = await bycf.shannz.turnstileMin(
+      url,
+      sitekey,
+      proxy || "host:port"
+    );
+
+    console.log('✅ Turnstile Token berhasil didapatkan');
+    
+    res.json({
+      success: true,
+      url: url,
+      sitekey: sitekey,
+      turnstileToken: token,
+      timestamp: new Date().toISOString()
+    });
+
+  } catch (error) {
+    console.error('❌ Error getting Turnstile token:', error.message);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message 
+    });
+  }
+});
+
+app.get('/api/cf/autofaucet', async (req, res) => {
+  try {
+    const { proxy } = req.query;
+    const url = "https://autofaucet.org/earn/faucet";
+    const sitekey = "0x4AAAAAAAeegevyhnJu7zGA";
+
+    console.log(`🎯 Request Autofaucet Bypass`);
+
+    const session = await bycf.shannz.wafSession(
+      url,
+      proxy || "host:port"
+    );
+
+    const token = await bycf.shannz.turnstileMin(
+      url,
+      sitekey,
+      proxy || "host:port"
+    );
+
+    console.log('✅ Autofaucet bypass berhasil');
+    
+    res.json({
+      success: true,
+      url: url,
+      sitekey: sitekey,
+      wafSession: {
+        cookies: session.cookies,
+        userAgent: session.headers['User-Agent'],
+        headers: session.headers
+      },
+      turnstileToken: token,
+      timestamp: new Date().toISOString()
+    });
+
+  } catch (error) {
+    console.error('❌ Error autofaucet bypass:', error.message);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message 
+    });
+  }
+});
+
+app.get('/api/cf/stats', async (req, res) => {
+  try {
+    console.log('📊 Request bycf stats');
+    
+    const stats = await bycf.shannz.stats();
+
+    res.json({
+      success: true,
+      stats: stats,
+      timestamp: new Date().toISOString()
+    });
+
+  } catch (error) {
+    console.error('❌ Error getting stats:', error.message);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message 
+    });
+  }
+});
+
+// ============================
+// TIKTOK & INSTAGRAM APIs
+// ============================
+
+app.get('/api/tiktok', async (req, res) => {
+  try {
+    const { url } = req.query;
+    
+    if (!url) {
+      return res.status(400).json({ 
+        success: false, 
+        error: "Parameter 'url' diperlukan" 
+      });
+    }
+
+    if (!url.includes('tiktok.com')) {
+      return res.status(400).json({ 
+        success: false, 
+        error: "URL harus dari TikTok" 
+      });
+    }
+
+    console.log(`🎵 Request TikTok Download: ${url}`);
+
+    // Import dinamis untuk ESM module
+    const { default: tiktokDl } = await import('./scrape/tiktokdl.js');
+    const result = await tiktokDl(url, DOMAIN);
+
+    if (!result.success) {
+      return res.status(500).json({ 
+        success: false, 
+        error: result.error 
+      });
+    }
+
+    console.log('✅ TikTok download berhasil');
+    res.json(result);
+
+  } catch (error) {
+    console.error('❌ Error in TikTok download:', error.message);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message 
+    });
+  }
+});
+
+app.get('/api/instagram', async (req, res) => {
+  try {
+    const { url } = req.query;
+    
+    if (!url) {
+      return res.status(400).json({ 
+        success: false, 
+        error: "Parameter 'url' diperlukan" 
+      });
+    }
+
+    if (!url.includes('instagram.com')) {
+      return res.status(400).json({ 
+        success: false, 
+        error: "URL harus dari Instagram" 
+      });
+    }
+
+    console.log(`📷 Request Instagram Download: ${url}`);
+
+    // Import dinamis untuk ESM module
+    const { default: instagramDl } = await import('./scrape/instagram.js');
+    const result = await instagramDl(url);
+
+    if (!result) {
+      return res.status(500).json({ 
+        success: false, 
+        error: "Gagal mengambil data Instagram" 
+      });
+    }
+
+    console.log('✅ Instagram download berhasil');
+    res.json({
+      success: true,
+      ...result
+    });
+
+  } catch (error) {
+    console.error('❌ Error in Instagram download:', error.message);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message 
+    });
+  }
+});
+
+// ============================
+// EXISTING APIs
+// ============================
+
+app.get('/api/fb-download', async (req, res) => {
+  try {
+    let { url, quality = '720p(HD)', upload = 'false' } = req.query;
+    if (!url) return res.status(400).json({ success: false, error: "Parameter 'url' diperlukan" });
+
+    if (!url.includes('facebook.com') && !url.includes('fb.com') && !url.includes('fb.watch')) {
+      return res.status(400).json({ success: false, error: "URL harus dari Facebook" });
+    }
+
+    console.log(`\n📥 Request Facebook Download: ${url}`);
+    console.log(`🎯 Kualitas: ${quality}, Upload: ${upload}`);
+
+    const result = await getFacebookVideoData(url);
+    
+    if (!result.downloads || result.downloads.length === 0) {
+      return res.status(404).json({ success: false, error: "Tidak ada hasil download yang ditemukan" });
+    }
+    
+    let selectedDownload = null;
+    
+    if (quality === '720p(HD)') {
+      selectedDownload = result.downloads.find(d => d.quality.includes('720p(HD)') || d.quality.includes('HD'));
+    } else if (quality === '360p(SD)') {
+      selectedDownload = result.downloads.find(d => d.quality.includes('360p(SD)') || d.quality.includes('SD'));
+    } else if (quality === 'Mp3') {
+      selectedDownload = result.downloads.find(d => d.quality.includes('Mp3') || d.type === 'audio');
+    }
+    
+    if (!selectedDownload) {
+      selectedDownload = result.downloads[0];
+      console.log(`⚠️  Kualitas ${quality} tidak ditemukan, menggunakan ${selectedDownload.quality} sebagai fallback`);
+    }
+    
+    console.log(`✅ Kualitas dipilih: ${selectedDownload.quality}`);
+    
+    const safeTitle = (result.title || 'facebook_video').replace(/[^\w\s.-]/g, '').replace(/\s+/g, '_').substring(0, 100);
+    const fileExt = selectedDownload.type === 'audio' ? 'mp3' : 'mp4';
+    const timestamp = Date.now();
+    const safeFilename = `${safeTitle}_${selectedDownload.quality}_${timestamp}.${fileExt}`;
+    
+    console.log(`📁 Filename: ${safeFilename}`);
+    
+    const downloadResult = await downloadAndSaveFile(selectedDownload.url, safeFilename, selectedDownload.quality);
+    
+    let uploadResult = null;
+    if (upload.toLowerCase() === 'true') {
+      try {
+        console.log('📤 Mengupload file Facebook...');
+        const fileBuffer = fs.readFileSync(downloadResult.path);
+        uploadResult = await uploadFile(fileBuffer);
+        console.log('✅ Upload Facebook berhasil');
+      } catch (uploadError) {
+        console.error('❌ Gagal mengupload file Facebook:', uploadError.message);
+      }
+    }
+    
+    const responseData = {
+      success: true,
+      title: result.title,
+      thumbnail: result.thumbnail,
+      selectedQuality: selectedDownload.quality,
+      type: selectedDownload.type,
+      downloadURL: downloadResult.downloadURL,
+      filename: downloadResult.filename,
+      size: downloadResult.size
+    };
+    
+    if (uploadResult) {
+      responseData.upload = uploadResult;
+    }
+    
+    responseData.availableQualities = result.downloads.map(d => ({
+      quality: d.quality,
+      type: d.type,
+      url: `${DOMAIN}/api/fb-download?url=${encodeURIComponent(url)}&quality=${encodeURIComponent(d.quality)}`
+    }));
+    
+    console.log('✅ Facebook download selesai');
+    return res.json(responseData);
+    
   } catch (err) {
-    res.status(500).json({ code: 500, message: err.message })
-  } finally {
-    if (browser) await browser.close().catch(() => {})
-    global.browserLimit++
+    console.error('❌ Error in fb-download:', err.message);
+    return res.status(500).json({ success: false, error: err.message });
   }
-})
+});
+
+app.get('/api/download', async (req, res) => {
+    try {
+        let { url, format = '360p', upload = 'false' } = req.query;
+        if (!url) return res.status(400).json({ success: false, error: "Parameter 'url' diperlukan" });
+
+        console.log(`\n📥 Request YouTube Download: ${url}`);
+        console.log(`🎯 Format: ${format}, Upload: ${upload}`);
+
+        if (format.toLowerCase() === 'mp4') {
+            format = '360p';
+        }
+
+        const result = await yt.download(url, format);
+        console.log(`✅ YouTube download berhasil: ${result.title}`);
+        
+        const fileExt = result.ftype === 'mp3' ? 'mp3' : 'mp4';
+        const safeFilename = result.title.replace(/[^\w\s.-]/g, '').replace(/\s+/g, '_') + '.' + fileExt;
+        const filePath = path.join(downloadsDir, safeFilename);
+
+        console.log(`⬇️  Mendownload file dari: ${result.dlink}`);
+        const response = await fetch(result.dlink);
+        if (!response.ok) throw new Error("Gagal unduh file dari dlink");
+
+        const fileStream = fs.createWriteStream(filePath);
+        await streamPipeline(response.body, fileStream);
+        console.log(`💾 File tersimpan: ${safeFilename}`);
+
+        let uploadResult = null;
+        if (upload.toLowerCase() === 'true') {
+            try {
+                console.log('📤 Mengupload file YouTube...');
+                const fileBuffer = fs.readFileSync(filePath);
+                uploadResult = await uploadFile(fileBuffer);
+                console.log('✅ Upload YouTube berhasil');
+            } catch (uploadError) {
+                console.error('❌ Gagal mengupload file YouTube:', uploadError.message);
+            }
+        }
+
+        const responseData = {
+            title: result.title,
+            format: result.ftype,
+            downloadURL: `${DOMAIN}/downloads/${encodeURIComponent(safeFilename)}`,
+            filename: safeFilename
+        };
+
+        if (uploadResult) {
+            responseData.upload = uploadResult;
+        }
+
+        console.log('✅ YouTube download selesai');
+        return res.json(responseData);
+    } catch (err) {
+        console.error('❌ Error in YouTube download:', err.message);
+        return res.status(500).json({ success: false, error: err.message });
+    }
+});
+
+app.post('/api/upload', upload.single('file'), async (req, res) => {
+    try {
+        if (!req.file) {
+            return res.status(400).json({ 
+                status: false,
+                error: "Tidak ada file yang diunggah" 
+            });
+        }
+
+        console.log('📤 Request upload file');
+        const uploadResult = await uploadFile(req.file.buffer);
+        return res.json(uploadResult);
+    } catch (err) {
+        console.error('❌ Upload error:', err.message);
+        return res.status(500).json({ 
+            status: false,
+            error: err.message 
+        });
+    }
+});
+
+app.post('/api/upload-base64', async (req, res) => {
+    try {
+        const { file } = req.body;
+        if (!file) {
+            return res.status(400).json({ 
+                status: false,
+                error: "Parameter 'file' diperlukan dalam format base64" 
+            });
+        }
+
+        console.log('📤 Request upload base64 file');
+        const base64Data = file.replace(/^data:.+;base64,/, '');
+        const fileBuffer = Buffer.from(base64Data, 'base64');
+        
+        const uploadResult = await uploadFile(fileBuffer);
+        return res.json(uploadResult);
+    } catch (err) {
+        console.error('❌ Upload base64 error:', err.message);
+        return res.status(500).json({ 
+            status: false,
+            error: err.message 
+        });
+    }
+});
+
+app.post('/api/upload-local', async (req, res) => {
+    try {
+        const { filename } = req.body;
+        if (!filename) {
+            return res.status(400).json({ 
+                status: false,
+                error: "Parameter 'filename' diperlukan" 
+            });
+        }
+
+        console.log(`📤 Request upload local file: ${filename}`);
+        const filePath = path.join(downloadsDir, filename);
+        if (!fs.existsSync(filePath)) {
+            return res.status(404).json({ 
+                status: false,
+                error: "File tidak ditemukan" 
+            });
+        }
+
+        const fileBuffer = fs.readFileSync(filePath);
+        const uploadResult = await uploadFile(fileBuffer);
+        return res.json(uploadResult);
+    } catch (err) {
+        console.error('❌ Upload local error:', err.message);
+        return res.status(500).json({ 
+            status: false,
+            error: err.message 
+        });
+    }
+});
+
+// ============================
+// DOWNLOAD FOLDER ACCESS
+// ============================
+
+app.get('/download/:folder/:filename', (req, res) => {
+  try {
+    const { folder, filename } = req.params;
+    const filePath = path.join(downloadsDir, folder, filename);
+    
+    if (!fs.existsSync(filePath)) {
+      return res.status(404).json({ 
+        success: false, 
+        error: "File tidak ditemukan" 
+      });
+    }
+
+    res.download(filePath, filename);
+  } catch (error) {
+    console.error('❌ Error serving file:', error.message);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message 
+    });
+  }
+});
+
+// ============================
+// SWAGGER & ROUTES
+// ============================
+
+const swaggerDocument = require('./docs/swagger');
+
+app.get('/api-docs/json', (req, res) => {
+    res.setHeader('Content-Type', 'application/json');
+    res.json(swaggerDocument);
+});
+
+app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument));
+
+app.get('/', (req, res) => {
+    res.sendFile(path.join(__dirname, 'public', 'index.html'));
+});
 
 app.use((req, res) => {
-  res.status(404).json({ message: 'Not Found' })
-})
-
-if (process.env.NODE_ENV !== 'development') {
-  const server = app.listen(port, () => {
-    console.log(`Server running on port ${port}`)
-  })
-  server.timeout = global.timeOut + 10000
-}
+    res.status(404).json({ status: false, error: 'Endpoint tidak ditemukan' });
+});
+
+// Cleanup expired sessions setiap 5 menit
+setInterval(() => {
+    const now = new Date();
+    let cleanedCount = 0;
+    
+    for (const [sessionId, session] of sessionStorage.entries()) {
+        if (new Date(session.expiresAt) < now) {
+            sessionStorage.delete(sessionId);
+            cleanedCount++;
+        }
+    }
+    
+    if (cleanedCount > 0) {
+        console.log(`🧹 Cleaned ${cleanedCount} expired sessions`);
+    }
+}, 5 * 60 * 1000);
+
+process.on('SIGINT', () => {
+    console.log('\nServer dimatikan');
+    process.exit(0);
+});
 
-if (process.env.NODE_ENV === 'development') {
-  module.exports = app
-}
+app.listen(PORT, () => {
+    console.log("=================================");
+    console.log(`🚀 Server berjalan di ${DOMAIN}`);
+    console.log(`📚 Swagger UI: ${DOMAIN}/api-docs`);
+    console.log(`⬇️  API Download YouTube: ${DOMAIN}/api/download`);
+    console.log(`📊 API Stats: ${DOMAIN}/api/cf/stats`);
+    console.log(`📤 API Upload: ${DOMAIN}/api/upload`);
+    console.log(`📁 Folder Unduhan: ${DOMAIN}/downloads`);
+    console.log("\n🆕 Enhanced BYCF Session Endpoints:");
+    console.log(`   POST ${DOMAIN}/api/cf/waf-session (dengan cookie lama)`);
+    console.log(`   POST ${DOMAIN}/api/cf/waf-session-with-host (dengan host khusus)`);
+    console.log(`   POST ${DOMAIN}/api/cf/renew-session (renew session)`);
+    console.log(`   GET  ${DOMAIN}/api/cf/session/:id (get session by ID)`);
+    console.log(`   GET  ${DOMAIN}/api/cf/sessions (get semua sessions)`);
+    console.log(`   DELETE ${DOMAIN}/api/cf/session/:id (hapus session)`);
+    console.log("=================================");
+});

package.json

@@ -1,16 +1,25 @@
 {
-  "name": "cf-bypass",
-  "version": "1.0",
-  "description": "get the cf_clearance cookie from any website",
+  "name": "eza",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
   "scripts": {
-    "start": "node index.js",
-    "dev": "nodemon index.js"
+    "test": "echo \"Error: no test specified\" && exit 1"
   },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
   "dependencies": {
+    "axios": "^1.11.0",
+    "cheerio": "^1.1.2",
+    "bycf": "^1.0.3",
+    "cors": "^2.8.5",
     "express": "^5.1.0",
-    "puppeteer-real-browser": "^1.4.0"
-  },
-  "devDependencies": {
-    "nodemon": "^3.1.10"
+    "file-type": "^21.0.0",
+    "multer": "^2.0.2",
+    "node-fetch": "^3.3.2",
+    "swagger-ui-express": "^5.0.1",
+    "yamljs": "^0.3.0"
   }
 }

public/index.html

@@ -0,0 +1,1040 @@
+<!DOCTYPE html>
+<html lang="id">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Social Media Downloader & Cloudflare Bypass API</title>
+    <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@3.25.0/swagger-ui.css">
+    <style>
+        body {
+            margin: 0;
+            padding: 0;
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+            background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+            color: #fff;
+            min-height: 100vh;
+        }
+        .header {
+            background-color: rgba(0, 0, 0, 0.7);
+            color: white;
+            padding: 1.5rem;
+            text-align: center;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.5);
+            border-bottom: 2px solid #4990e2;
+        }
+        .header h1 {
+            margin: 0;
+            font-size: 2.5rem;
+            background: linear-gradient(90deg, #4990e2, #00c4cc);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+        }
+        .header p {
+            margin: 0.5rem 0 0;
+            font-size: 1.2rem;
+            opacity: 0.9;
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 2rem;
+        }
+        .info-box {
+            background: rgba(255, 255, 255, 0.1);
+            border-radius: 8px;
+            padding: 1.5rem;
+            margin-bottom: 2rem;
+            box-shadow: 0 4px 15px rgba(0, 0, 0, 0.2);
+            border-left: 4px solid #4990e2;
+            backdrop-filter: blur(10px);
+        }
+        .info-box h3 {
+            margin-top: 0;
+            color: #4990e2;
+        }
+        .info-content {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 1.5rem;
+        }
+        .info-item {
+            flex: 1;
+            min-width: 250px;
+            background: rgba(0, 0, 0, 0.3);
+            padding: 1rem;
+            border-radius: 6px;
+        }
+        .info-item h4 {
+            margin: 0 0 0.5rem;
+            color: #00c4cc;
+        }
+        .info-item p {
+            margin: 0;
+            font-size: 0.95rem;
+        }
+        .try-box {
+            background: rgba(0, 0, 0, 0.3);
+            border-radius: 8px;
+            padding: 1.5rem;
+            margin-bottom: 2rem;
+        }
+        .try-box h3 {
+            margin-top: 0;
+            color: #4990e2;
+        }
+        .try-form {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 1rem;
+            margin-bottom: 1rem;
+        }
+        .try-form input, .try-form select, .try-form textarea {
+            flex: 1;
+            min-width: 200px;
+            padding: 0.8rem;
+            border: 1px solid #4990e2;
+            border-radius: 4px;
+            background: rgba(0, 0, 0, 0.5);
+            color: white;
+            font-family: monospace;
+            font-size: 0.9rem;
+        }
+        .try-form textarea {
+            min-height: 80px;
+            resize: vertical;
+        }
+        .try-form button {
+            padding: 0.8rem 1.5rem;
+            background: linear-gradient(90deg, #4990e2, #00c4cc);
+            border: none;
+            border-radius: 4px;
+            color: white;
+            font-weight: bold;
+            cursor: pointer;
+            transition: transform 0.2s;
+        }
+        .try-form button:hover {
+            transform: translateY(-2px);
+        }
+        .upload-form {
+            display: flex;
+            flex-direction: column;
+            gap: 1rem;
+            margin-bottom: 1rem;
+        }
+        .upload-form input[type="file"] {
+            padding: 0.8rem;
+            border: 1px solid #4990e2;
+            border-radius: 4px;
+            background: rgba(0, 0, 0, 0.5);
+            color: white;
+        }
+        .upload-form button {
+            padding: 0.8rem 1.5rem;
+            background: linear-gradient(90deg, #ff6b6b, #ff9e7d);
+            border: none;
+            border-radius: 4px;
+            color: white;
+            font-weight: bold;
+            cursor: pointer;
+            transition: transform 0.2s;
+        }
+        .upload-form button:hover {
+            transform: translateY(-2px);
+        }
+        .result-box {
+            background: rgba(0, 0, 0, 0.3);
+            border-radius: 8px;
+            padding: 1.5rem;
+            margin-top: 1.5rem;
+            display: none;
+        }
+        .result-box h4 {
+            margin-top: 0;
+            color: #4990e2;
+        }
+        .result-content {
+            background: rgba(0, 0, 0, 0.5);
+            padding: 1rem;
+            border-radius: 6px;
+            overflow-x: auto;
+            max-height: 400px;
+            overflow-y: auto;
+        }
+        .preview-image {
+            max-width: 100%;
+            max-height: 200px;
+            margin-top: 1rem;
+            border-radius: 4px;
+            display: none;
+        }
+        .swagger-ui {
+            box-shadow: 0 4px 15px rgba(0, 0, 0, 0.2);
+            border-radius: 8px;
+            overflow: hidden;
+        }
+        .footer {
+            text-align: center;
+            padding: 2rem;
+            margin-top: 2rem;
+            font-size: 0.9rem;
+            opacity: 0.7;
+        }
+        .tabs {
+            display: flex;
+            margin-bottom: 1rem;
+            border-bottom: 1px solid #4990e2;
+            flex-wrap: wrap;
+        }
+        .tab {
+            padding: 0.8rem 1.5rem;
+            cursor: pointer;
+            background: rgba(0, 0, 0, 0.3);
+            border: 1px solid transparent;
+            border-bottom: none;
+            border-top-left-radius: 6px;
+            border-top-right-radius: 6px;
+            margin-right: 0.5rem;
+            margin-bottom: 0.5rem;
+            transition: all 0.3s ease;
+        }
+        .tab.active {
+            background: rgba(73, 144, 226, 0.2);
+            border-color: #4990e2;
+        }
+        .tab-content {
+            display: none;
+        }
+        .tab-content.active {
+            display: block;
+        }
+        .social-tab {
+            background: linear-gradient(90deg, #ff6b6b, #ff9e7d);
+        }
+        .cloudflare-tab {
+            background: linear-gradient(90deg, #4990e2, #00c4cc);
+        }
+        .session-tab {
+            background: linear-gradient(90deg, #9b59b6, #8e44ad);
+        }
+        .form-group {
+            margin-bottom: 1rem;
+        }
+        .form-group label {
+            display: block;
+            margin-bottom: 0.5rem;
+            color: #00c4cc;
+            font-weight: bold;
+        }
+        .cookie-input {
+            font-family: monospace;
+            font-size: 0.8rem;
+        }
+        .session-actions {
+            display: flex;
+            gap: 0.5rem;
+            margin-top: 1rem;
+        }
+        .session-actions button {
+            flex: 1;
+            padding: 0.5rem 1rem;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 0.8rem;
+        }
+        .btn-primary {
+            background: #4990e2;
+            color: white;
+        }
+        .btn-success {
+            background: #27ae60;
+            color: white;
+        }
+        .btn-danger {
+            background: #e74c3c;
+            color: white;
+        }
+        .btn-warning {
+            background: #f39c12;
+            color: white;
+        }
+        .sessions-list {
+            max-height: 300px;
+            overflow-y: auto;
+            margin-top: 1rem;
+        }
+        .session-item {
+            background: rgba(0, 0, 0, 0.3);
+            padding: 1rem;
+            margin-bottom: 0.5rem;
+            border-radius: 4px;
+            border-left: 4px solid #9b59b6;
+        }
+        .session-header {
+            display: flex;
+            justify-content: between;
+            align-items: center;
+            margin-bottom: 0.5rem;
+        }
+        .session-id {
+            font-weight: bold;
+            color: #9b59b6;
+        }
+        .session-meta {
+            font-size: 0.8rem;
+            opacity: 0.7;
+        }
+        @media (max-width: 768px) {
+            .container {
+                padding: 1rem;
+            }
+            .header h1 {
+                font-size: 2rem;
+            }
+            .tabs {
+                flex-direction: column;
+            }
+            .tab {
+                margin-right: 0;
+                margin-bottom: 0.5rem;
+            }
+            .try-form {
+                flex-direction: column;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>Social Media Downloader & Cloudflare Bypass API</h1>
+        <p>Download video dari YouTube, Facebook, TikTok, Instagram + BYCF Session Management</p>
+    </div>
+
+    <div class="container">
+        <div class="info-box">
+            <h3>Informasi API</h3>
+            <div class="info-content">
+                <div class="info-item">
+                    <h4>Domain</h4>
+                    <p id="domain-info">Loading...</p>
+                </div>
+                <div class="info-item">
+                    <h4>Port</h4>
+                    <p id="port-info">7860</p>
+                </div>
+                <div class="info-item">
+                    <h4>Platform Support</h4>
+                    <p>YouTube, Facebook, TikTok, Instagram</p>
+                </div>
+                <div class="info-item">
+                    <h4>BYCF Features</h4>
+                    <p>WAF Session, Turnstile, Session Management</p>
+                </div>
+            </div>
+        </div>
+
+        <div class="tabs">
+            <div class="tab active" onclick="switchTab('download-tab')">YouTube</div>
+            <div class="tab" onclick="switchTab('facebook-tab')">Facebook</div>
+            <div class="tab social-tab" onclick="switchTab('tiktok-tab')">TikTok</div>
+            <div class="tab social-tab" onclick="switchTab('instagram-tab')">Instagram</div>
+            <div class="tab" onclick="switchTab('upload-tab')">Upload File</div>
+            <div class="tab cloudflare-tab" onclick="switchTab('cloudflare-tab')">Cloudflare</div>
+            <div class="tab session-tab" onclick="switchTab('session-tab')">Session Management</div>
+        </div>
+
+        <!-- YouTube Tab -->
+        <div id="download-tab" class="tab-content active">
+            <div class="try-box">
+                <h3>Download Video YouTube</h3>
+                <div class="try-form">
+                    <input type="text" id="yt-url" placeholder="Masukkan URL YouTube" value="https://www.youtube.com/watch?v=dQw4w9WgXcQ">
+                    <select id="format">
+                        <option value="mp3">MP3</option>
+                        <option value="360p">MP4 360p</option>
+                        <option value="720p">MP4 720p</option>
+                        <option value="1080p">MP4 1080p</option>
+                    </select>
+                    <select id="upload-option">
+                        <option value="false">Hanya Download</option>
+                        <option value="true">Download + Upload</option>
+                    </select>
+                    <button onclick="testDownloadApi('youtube')">Download</button>
+                </div>
+                <div class="result-box" id="download-result">
+                    <h4>Hasil Download</h4>
+                    <div class="result-content">
+                        <pre id="download-result-content"></pre>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Facebook Tab -->
+        <div id="facebook-tab" class="tab-content">
+            <div class="try-box">
+                <h3>Download Video Facebook</h3>
+                <div class="try-form">
+                    <input type="text" id="fb-url" placeholder="Masukkan URL Facebook">
+                    <select id="fb-quality">
+                        <option value="720p(HD)">720p (HD)</option>
+                        <option value="360p(SD)">360p (SD)</option>
+                        <option value="Mp3">MP3 Audio</option>
+                    </select>
+                    <button onclick="testDownloadApi('facebook')">Download</button>
+                </div>
+                <div class="result-box" id="fb-result">
+                    <h4>Hasil Download</h4>
+                    <div class="result-content">
+                        <pre id="fb-result-content"></pre>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- TikTok Tab -->
+        <div id="tiktok-tab" class="tab-content">
+            <div class="try-box">
+                <h3>Download Video TikTok</h3>
+                <div class="try-form">
+                    <input type="text" id="tiktok-url" placeholder="Masukkan URL TikTok">
+                    <button onclick="testDownloadApi('tiktok')">Download</button>
+                </div>
+                <div class="result-box" id="tiktok-result">
+                    <h4>Hasil Download</h4>
+                    <div class="result-content">
+                        <pre id="tiktok-result-content"></pre>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Instagram Tab -->
+        <div id="instagram-tab" class="tab-content">
+            <div class="try-box">
+                <h3>Download Konten Instagram</h3>
+                <div class="try-form">
+                    <input type="text" id="instagram-url" placeholder="Masukkan URL Instagram">
+                    <button onclick="testDownloadApi('instagram')">Download</button>
+                </div>
+                <div class="result-box" id="instagram-result">
+                    <h4>Hasil Download</h4>
+                    <div class="result-content">
+                        <pre id="instagram-result-content"></pre>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Upload Tab -->
+        <div id="upload-tab" class="tab-content">
+            <div class="try-box">
+                <h3>Upload File (WebP, JPEG, PNG, dll)</h3>
+                <div class="upload-form">
+                    <input type="file" id="file-input" accept=".webp,.jpg,.jpeg,.png,.gif,.mp4,.mp3">
+                    <button onclick="uploadFile()">Upload File</button>
+                </div>
+                <div class="result-box" id="upload-result">
+                    <h4>Hasil Upload</h4>
+                    <div class="result-content">
+                        <pre id="upload-result-content"></pre>
+                    </div>
+                    <img id="preview-image" class="preview-image" alt="Preview gambar">
+                </div>
+            </div>
+        </div>
+
+        <!-- Cloudflare Tab -->
+        <div id="cloudflare-tab" class="tab-content">
+            <div class="try-box">
+                <h3>Cloudflare Bypass Tools</h3>
+                
+                <div class="form-group">
+                    <label>WAF Session (GET)</label>
+                    <div class="try-form">
+                        <input type="text" id="cf-url" placeholder="Masukkan URL yang diproteksi Cloudflare">
+                        <input type="text" id="cf-proxy" placeholder="Proxy (opsional) host:port">
+                        <button onclick="testCFApi('waf')">Get WAF Session</button>
+                    </div>
+                </div>
+
+                <div class="form-group">
+                    <label>Turnstile CAPTCHA</label>
+                    <div class="try-form">
+                        <input type="text" id="cf-turnstile-url" placeholder="URL dengan Turnstile">
+                        <input type="text" id="cf-sitekey" placeholder="Sitekey Turnstile">
+                        <input type="text" id="cf-turnstile-proxy" placeholder="Proxy (opsional) host:port">
+                        <button onclick="testCFApi('turnstile')">Solve Turnstile</button>
+                    </div>
+                </div>
+
+                <div class="form-group">
+                    <label>Autofaucet Bypass</label>
+                    <div class="try-form">
+                        <input type="text" id="cf-autofaucet-proxy" placeholder="Proxy (opsional) host:port">
+                        <button onclick="testCFApi('autofaucet')">Bypass Autofaucet</button>
+                    </div>
+                </div>
+
+                <div class="result-box" id="cf-result">
+                    <h4>Hasil Cloudflare Bypass</h4>
+                    <div class="result-content">
+                        <pre id="cf-result-content"></pre>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Session Management Tab -->
+        <div id="session-tab" class="tab-content">
+            <div class="try-box">
+                <h3>BYCF Session Management</h3>
+
+                <!-- Create Session with Old Cookies -->
+                <div class="form-group">
+                    <label>Create WAF Session dengan Cookie Lama</label>
+                    <div class="try-form">
+                        <input type="text" id="session-url" placeholder="URL target" value="https://www.example.com">
+                        <input type="text" id="session-proxy" placeholder="Proxy (opsional) host:port">
+                    </div>
+                    <textarea id="old-cookies" placeholder='Cookie lama (JSON format): {"old_cookie": "value123", "session_id": "abc456"}' class="cookie-input"></textarea>
+                    <div class="session-actions">
+                        <button class="btn-primary" onclick="createSession()">Create Session</button>
+                        <button class="btn-success" onclick="createSessionWithHost()">Create with Host</button>
+                    </div>
+                </div>
+
+                <!-- Session Operations -->
+                <div class="form-group">
+                    <label>Session Operations</label>
+                    <div class="try-form">
+                        <input type="text" id="session-id" placeholder="Session ID">
+                        <input type="text" id="renew-url" placeholder="URL untuk renew (opsional)">
+                    </div>
+                    <div class="session-actions">
+                        <button class="btn-primary" onclick="getSession()">Get Session</button>
+                        <button class="btn-warning" onclick="renewSession()">Renew Session</button>
+                        <button class="btn-danger" onclick="deleteSession()">Delete Session</button>
+                        <button class="btn-success" onclick="getAllSessions()">Get All Sessions</button>
+                    </div>
+                </div>
+
+                <!-- Active Sessions List -->
+                <div class="sessions-list" id="sessions-list">
+                    <!-- Sessions will be populated here -->
+                </div>
+
+                <div class="result-box" id="session-result">
+                    <h4>Hasil Session Management</h4>
+                    <div class="result-content">
+                        <pre id="session-result-content"></pre>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Swagger UI -->
+        <div id="swagger-ui"></div>
+    </div>
+
+    <div class="footer">
+        <p>Social Media Downloader & Cloudflare Bypass API &copy; 2024</p>
+    </div>
+
+    <script src="https://unpkg.com/swagger-ui-dist@3.25.0/swagger-ui-bundle.js"></script>
+    <script>
+        const currentDomain = window.location.origin;
+        const apiBaseUrl = currentDomain;
+        
+        document.getElementById('domain-info').textContent = currentDomain;
+
+        // Tab Management
+        function switchTab(tabId) {
+            document.querySelectorAll('.tab-content').forEach(tab => {
+                tab.classList.remove('active');
+            });
+            document.getElementById(tabId).classList.add('active');
+            
+            document.querySelectorAll('.tab').forEach(tab => {
+                tab.classList.remove('active');
+            });
+            event.currentTarget.classList.add('active');
+
+            // Refresh sessions list when switching to session tab
+            if (tabId === 'session-tab') {
+                getAllSessions();
+            }
+        }
+
+        // Download APIs
+        function testDownloadApi(platform) {
+            let url, endpoint, resultDiv, resultContent;
+            
+            switch(platform) {
+                case 'youtube':
+                    url = document.getElementById('yt-url').value;
+                    endpoint = '/api/download';
+                    resultDiv = document.getElementById('download-result');
+                    resultContent = document.getElementById('download-result-content');
+                    break;
+                case 'facebook':
+                    url = document.getElementById('fb-url').value;
+                    endpoint = '/api/fb-download';
+                    resultDiv = document.getElementById('fb-result');
+                    resultContent = document.getElementById('fb-result-content');
+                    break;
+                case 'tiktok':
+                    url = document.getElementById('tiktok-url').value;
+                    endpoint = '/api/tiktok';
+                    resultDiv = document.getElementById('tiktok-result');
+                    resultContent = document.getElementById('tiktok-result-content');
+                    break;
+                case 'instagram':
+                    url = document.getElementById('instagram-url').value;
+                    endpoint = '/api/instagram';
+                    resultDiv = document.getElementById('instagram-result');
+                    resultContent = document.getElementById('instagram-result-content');
+                    break;
+            }
+            
+            if (!url) {
+                resultContent.textContent = 'Error: URL harus diisi';
+                resultDiv.style.display = 'block';
+                return;
+            }
+            
+            resultContent.textContent = 'Memproses download...';
+            resultDiv.style.display = 'block';
+            
+            let apiUrl = `${apiBaseUrl}${endpoint}?url=${encodeURIComponent(url)}`;
+            
+            if (platform === 'youtube') {
+                const format = document.getElementById('format').value;
+                const upload = document.getElementById('upload-option').value;
+                apiUrl += `&format=${format}&upload=${upload}`;
+            } else if (platform === 'facebook') {
+                const quality = document.getElementById('fb-quality').value;
+                apiUrl += `&quality=${quality}`;
+            }
+            
+            fetch(apiUrl)
+                .then(response => response.json())
+                .then(data => {
+                    resultContent.textContent = JSON.stringify(data, null, 2);
+                    
+                    if (data.downloadURL || (data.downloadInfo && data.downloadInfo.download_url)) {
+                        const downloadUrl = data.downloadURL || data.downloadInfo.download_url;
+                        const downloadBtn = document.createElement('a');
+                        downloadBtn.href = downloadUrl;
+                        downloadBtn.target = '_blank';
+                        downloadBtn.textContent = 'Download File';
+                        downloadBtn.style.display = 'block';
+                        downloadBtn.style.marginTop = '1rem';
+                        downloadBtn.style.padding = '0.5rem 1rem';
+                        downloadBtn.style.background = '#4990e2';
+                        downloadBtn.style.color = 'white';
+                        downloadBtn.style.borderRadius = '4px';
+                        downloadBtn.style.textDecoration = 'none';
+                        
+                        resultContent.appendChild(downloadBtn);
+                    }
+                })
+                .catch(error => {
+                    resultContent.textContent = 'Error: ' + error.message;
+                });
+        }
+
+        // Cloudflare APIs
+        function testCFApi(type) {
+            const resultDiv = document.getElementById('cf-result');
+            const resultContent = document.getElementById('cf-result-content');
+            
+            let apiUrl, params = '';
+            
+            switch(type) {
+                case 'waf':
+                    const url = document.getElementById('cf-url').value;
+                    const proxy = document.getElementById('cf-proxy').value;
+                    if (!url) {
+                        resultContent.textContent = 'Error: URL harus diisi';
+                        resultDiv.style.display = 'block';
+                        return;
+                    }
+                    apiUrl = `/api/cf/waf-session?url=${encodeURIComponent(url)}`;
+                    if (proxy) apiUrl += `&proxy=${encodeURIComponent(proxy)}`;
+                    break;
+                    
+                case 'turnstile':
+                    const turnstileUrl = document.getElementById('cf-turnstile-url').value;
+                    const sitekey = document.getElementById('cf-sitekey').value;
+                    const turnstileProxy = document.getElementById('cf-turnstile-proxy').value;
+                    if (!turnstileUrl || !sitekey) {
+                        resultContent.textContent = 'Error: URL dan Sitekey harus diisi';
+                        resultDiv.style.display = 'block';
+                        return;
+                    }
+                    apiUrl = `/api/cf/turnstile?url=${encodeURIComponent(turnstileUrl)}&sitekey=${encodeURIComponent(sitekey)}`;
+                    if (turnstileProxy) apiUrl += `&proxy=${encodeURIComponent(turnstileProxy)}`;
+                    break;
+                    
+                case 'autofaucet':
+                    const autofaucetProxy = document.getElementById('cf-autofaucet-proxy').value;
+                    apiUrl = '/api/cf/autofaucet';
+                    if (autofaucetProxy) apiUrl += `?proxy=${encodeURIComponent(autofaucetProxy)}`;
+                    break;
+            }
+            
+            resultContent.textContent = 'Memproses...';
+            resultDiv.style.display = 'block';
+            
+            fetch(apiBaseUrl + apiUrl)
+                .then(response => response.json())
+                .then(data => {
+                    resultContent.textContent = JSON.stringify(data, null, 2);
+                })
+                .catch(error => {
+                    resultContent.textContent = 'Error: ' + error.message;
+                });
+        }
+
+        // Session Management Functions
+        function createSession() {
+            const url = document.getElementById('session-url').value;
+            const proxy = document.getElementById('session-proxy').value;
+            const cookiesInput = document.getElementById('old-cookies').value;
+            const resultDiv = document.getElementById('session-result');
+            const resultContent = document.getElementById('session-result-content');
+
+            if (!url) {
+                resultContent.textContent = 'Error: URL harus diisi';
+                resultDiv.style.display = 'block';
+                return;
+            }
+
+            let cookies = {};
+            if (cookiesInput) {
+                try {
+                    cookies = JSON.parse(cookiesInput);
+                } catch (e) {
+                    resultContent.textContent = 'Error: Format cookie tidak valid (harus JSON)';
+                    resultDiv.style.display = 'block';
+                    return;
+                }
+            }
+
+            resultContent.textContent = 'Membuat session...';
+            resultDiv.style.display = 'block';
+
+            fetch(`${apiBaseUrl}/api/cf/waf-session`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    url: url,
+                    proxy: proxy,
+                    cookies: cookies
+                })
+            })
+            .then(response => response.json())
+            .then(data => {
+                resultContent.textContent = JSON.stringify(data, null, 2);
+                if (data.success && data.sessionId) {
+                    document.getElementById('session-id').value = data.sessionId;
+                    getAllSessions(); // Refresh sessions list
+                }
+            })
+            .catch(error => {
+                resultContent.textContent = 'Error: ' + error.message;
+            });
+        }
+
+        function createSessionWithHost() {
+            const url = document.getElementById('session-url').value;
+            const proxy = document.getElementById('session-proxy').value;
+            const cookiesInput = document.getElementById('old-cookies').value;
+            const resultDiv = document.getElementById('session-result');
+            const resultContent = document.getElementById('session-result-content');
+
+            if (!url) {
+                resultContent.textContent = 'Error: URL harus diisi';
+                resultDiv.style.display = 'block';
+                return;
+            }
+
+            // Extract host from URL
+            const host = new URL(url).host;
+
+            let cookies = {};
+            if (cookiesInput) {
+                try {
+                    cookies = JSON.parse(cookiesInput);
+                } catch (e) {
+                    resultContent.textContent = 'Error: Format cookie tidak valid (harus JSON)';
+                    resultDiv.style.display = 'block';
+                    return;
+                }
+            }
+
+            resultContent.textContent = 'Membuat session dengan host...';
+            resultDiv.style.display = 'block';
+
+            fetch(`${apiBaseUrl}/api/cf/waf-session-with-host`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    url: url,
+                    host: host,
+                    proxy: proxy,
+                    cookies: cookies
+                })
+            })
+            .then(response => response.json())
+            .then(data => {
+                resultContent.textContent = JSON.stringify(data, null, 2);
+                if (data.success && data.sessionId) {
+                    document.getElementById('session-id').value = data.sessionId;
+                    getAllSessions(); // Refresh sessions list
+                }
+            })
+            .catch(error => {
+                resultContent.textContent = 'Error: ' + error.message;
+            });
+        }
+
+        function getSession() {
+            const sessionId = document.getElementById('session-id').value;
+            const resultDiv = document.getElementById('session-result');
+            const resultContent = document.getElementById('session-result-content');
+
+            if (!sessionId) {
+                resultContent.textContent = 'Error: Session ID harus diisi';
+                resultDiv.style.display = 'block';
+                return;
+            }
+
+            resultContent.textContent = 'Mengambil session...';
+            resultDiv.style.display = 'block';
+
+            fetch(`${apiBaseUrl}/api/cf/session/${sessionId}`)
+                .then(response => response.json())
+                .then(data => {
+                    resultContent.textContent = JSON.stringify(data, null, 2);
+                })
+                .catch(error => {
+                    resultContent.textContent = 'Error: ' + error.message;
+                });
+        }
+
+        function renewSession() {
+            const sessionId = document.getElementById('session-id').value;
+            const renewUrl = document.getElementById('renew-url').value;
+            const resultDiv = document.getElementById('session-result');
+            const resultContent = document.getElementById('session-result-content');
+
+            if (!sessionId) {
+                resultContent.textContent = 'Error: Session ID harus diisi';
+                resultDiv.style.display = 'block';
+                return;
+            }
+
+            resultContent.textContent = 'Memperbarui session...';
+            resultDiv.style.display = 'block';
+
+            fetch(`${apiBaseUrl}/api/cf/renew-session`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    sessionId: sessionId,
+                    url: renewUrl || 'https://www.example.com'
+                })
+            })
+            .then(response => response.json())
+            .then(data => {
+                resultContent.textContent = JSON.stringify(data, null, 2);
+                getAllSessions(); // Refresh sessions list
+            })
+            .catch(error => {
+                resultContent.textContent = 'Error: ' + error.message;
+            });
+        }
+
+        function deleteSession() {
+            const sessionId = document.getElementById('session-id').value;
+            const resultDiv = document.getElementById('session-result');
+            const resultContent = document.getElementById('session-result-content');
+
+            if (!sessionId) {
+                resultContent.textContent = 'Error: Session ID harus diisi';
+                resultDiv.style.display = 'block';
+                return;
+            }
+
+            resultContent.textContent = 'Menghapus session...';
+            resultDiv.style.display = 'block';
+
+            fetch(`${apiBaseUrl}/api/cf/session/${sessionId}`, {
+                method: 'DELETE'
+            })
+            .then(response => response.json())
+            .then(data => {
+                resultContent.textContent = JSON.stringify(data, null, 2);
+                getAllSessions(); // Refresh sessions list
+            })
+            .catch(error => {
+                resultContent.textContent = 'Error: ' + error.message;
+            });
+        }
+
+        function getAllSessions() {
+            const sessionsList = document.getElementById('sessions-list');
+            const resultDiv = document.getElementById('session-result');
+            const resultContent = document.getElementById('session-result-content');
+
+            sessionsList.innerHTML = '<p>Memuat sessions...</p>';
+
+            fetch(`${apiBaseUrl}/api/cf/sessions`)
+                .then(response => response.json())
+                .then(data => {
+                    if (data.success && data.sessions && data.sessions.length > 0) {
+                        sessionsList.innerHTML = '';
+                        data.sessions.forEach(session => {
+                            const sessionItem = document.createElement('div');
+                            sessionItem.className = 'session-item';
+                            sessionItem.innerHTML = `
+                                <div class="session-header">
+                                    <span class="session-id">${session.id}</span>
+                                    <span class="session-meta">Usage: ${session.usageCount}</span>
+                                </div>
+                                <div class="session-meta">
+                                    Created: ${new Date(session.createdAt).toLocaleString()} | 
+                                    Last Used: ${new Date(session.lastUsed).toLocaleString()}
+                                </div>
+                                <div class="session-actions">
+                                    <button class="btn-primary" onclick="setSessionId('${session.id}')">Select</button>
+                                    <button class="btn-warning" onclick="renewSpecificSession('${session.id}')">Renew</button>
+                                    <button class="btn-danger" onclick="deleteSpecificSession('${session.id}')">Delete</button>
+                                </div>
+                            `;
+                            sessionsList.appendChild(sessionItem);
+                        });
+                    } else {
+                        sessionsList.innerHTML = '<p>Tidak ada session aktif</p>';
+                    }
+                })
+                .catch(error => {
+                    sessionsList.innerHTML = '<p>Error loading sessions</p>';
+                });
+        }
+
+        function setSessionId(sessionId) {
+            document.getElementById('session-id').value = sessionId;
+        }
+
+        function renewSpecificSession(sessionId) {
+            document.getElementById('session-id').value = sessionId;
+            renewSession();
+        }
+
+        function deleteSpecificSession(sessionId) {
+            document.getElementById('session-id').value = sessionId;
+            deleteSession();
+        }
+
+        // Upload Function
+        function uploadFile() {
+            const fileInput = document.getElementById('file-input');
+            const resultDiv = document.getElementById('upload-result');
+            const resultContent = document.getElementById('upload-result-content');
+            const previewImage = document.getElementById('preview-image');
+            
+            if (!fileInput.files || fileInput.files.length === 0) {
+                resultContent.textContent = 'Error: Pilih file terlebih dahulu';
+                resultDiv.style.display = 'block';
+                return;
+            }
+            
+            const file = fileInput.files[0];
+            resultContent.textContent = 'Mengupload file...';
+            resultDiv.style.display = 'block';
+            previewImage.style.display = 'none';
+            
+            if (file.type.startsWith('image/')) {
+                const reader = new FileReader();
+                reader.onload = function(e) {
+                    previewImage.src = e.target.result;
+                    previewImage.style.display = 'block';
+                };
+                reader.readAsDataURL(file);
+            }
+            
+            const formData = new FormData();
+            formData.append('file', file);
+            
+            fetch(`${apiBaseUrl}/api/upload`, {
+                method: 'POST',
+                body: formData
+            })
+            .then(response => response.json())
+            .then(data => {
+                resultContent.textContent = JSON.stringify(data, null, 2);
+                
+                if (data.path) {
+                    const link = document.createElement('a');
+                    link.href = data.path;
+                    link.target = '_blank';
+                    link.textContent = 'Buka File';
+                    link.style.display = 'block';
+                    link.style.marginTop = '1rem';
+                    link.style.padding = '0.5rem 1rem';
+                    link.style.background = '#ff6b6b';
+                    link.style.color = 'white';
+                    link.style.borderRadius = '4px';
+                    link.style.textDecoration = 'none';
+                    
+                    resultContent.appendChild(link);
+                }
+            })
+            .catch(error => {
+                resultContent.textContent = 'Error: ' + error.message;
+            });
+        }
+
+        // Initialize Swagger UI
+        setTimeout(() => {
+            try {
+                const ui = SwaggerUIBundle({
+                    url: `${apiBaseUrl}/api-docs/json`,
+                    dom_id: '#swagger-ui',
+                    presets: [
+                        SwaggerUIBundle.presets.apis,
+                        SwaggerUIBundle.presets.standalone
+                    ],
+                    layout: "BaseLayout"
+                });
+            } catch (error) {
+                console.error('Error loading Swagger UI:', error);
+                document.getElementById('swagger-ui').innerHTML = `
+                    <div style="padding: 20px; color: white; text-align: center;">
+                        <h3>Swagger UI tidak dapat dimuat</h3>
+                        <p>Pastikan server berjalan dan endpoint /api-docs/json dapat diakses</p>
+                        <a href="${apiBaseUrl}/api-docs/json" target="_blank" style="color: #4990e2;">Cek endpoint spec</a>
+                    </div>
+                `;
+            }
+        }, 1000);
+
+        // Load sessions on page load if on session tab
+        window.addEventListener('load', function() {
+            if (window.location.hash === '#session-tab') {
+                switchTab('session-tab');
+            }
+        });
+    </script>
+</body>
+</html>

scrape/instagramdl.js

@@ -0,0 +1,197 @@
+const cheerio = require("cheerio");
+const Form = require("form-data");
+const axios = require("axios");
+
+function extractInnerHtml(data) {
+  try {
+    return data
+      .split('getElementById("download-section").innerHTML = "')[1]
+      .split('"; document.getElementById("inputData").remove(); ')[0]
+      .replace(/\\(\\)?/g, "");
+  } catch {
+    return null;
+  }
+}
+
+function decode(encoded) {
+  try {
+    const karakter = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/".split("");
+    const [h, u, n, t, e, r] = encoded;
+    function decodeInner(d, e, f) {
+      const h = karakter.slice(0, e);
+      const i = karakter.slice(0, f);
+      let j = d
+        .split("")
+        .reverse()
+        .reduce((a, b, c) => (h.indexOf(b) !== -1 ? a + h.indexOf(b) * Math.pow(e, c) : a), 0);
+      let k = "";
+      while (j > 0) {
+        k = i[j % f] + k;
+        j = Math.floor(j / f);
+      }
+      return k || "0";
+    }
+    let hasil = "";
+    for (let i = 0, len = h.length; i < len; i++) {
+      let s = "";
+      while (h[i] !== n[e]) {
+        s += h[i];
+        i++;
+      }
+      for (let j = 0; j < n.length; j++) {
+        s = s.replace(new RegExp(n[j], "g"), j.toString());
+      }
+      hasil += String.fromCharCode(decodeInner(s, e, 10) - t);
+    }
+    return decodeURIComponent(encodeURIComponent(hasil));
+  } catch {
+    return null;
+  }
+}
+
+function getType(url) {
+  return ["/p/", "/reel"].some((a) => url.includes(a)) ? "post" : "profile";
+}
+
+async function getUserInfo(username) {
+  try {
+    const res = await axios.get(`https://api-ig.storiesig.info/api/userInfoByUsername/${username}`, {
+      headers: { Referer: "https://storiesig.info/" },
+    });
+    return res.data?.result?.user || {};
+  } catch {
+    return {};
+  }
+}
+
+function getUsername(url) {
+  try {
+    const potongan = url.split("://")[1].split("/")[1];
+    return potongan || null;
+  } catch {
+    return null;
+  }
+}
+
+async function instagram(q) {
+  try {
+    const kontenInstagram = await (
+      await fetch(q, {
+        headers: {
+          accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+          "accept-language": "id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7",
+          "cache-control": "no-cache",
+          dpr: "3",
+          pragma: "no-cache",
+          "sec-ch-prefers-color-scheme": "dark",
+          "sec-ch-ua": '"Not-A.Brand";v="99", "Chromium";v="124"',
+          "sec-ch-ua-full-version-list": '"Not-A.Brand";v="99.0.0.0", "Chromium";v="124.0.6327.4"',
+          "sec-ch-ua-mobile": "?1",
+          "sec-ch-ua-model": '"Infinix X6882"',
+          "sec-ch-ua-platform": '"Android"',
+          "sec-ch-ua-platform-version": '"14.0.0"',
+          "sec-fetch-dest": "document",
+          "sec-fetch-mode": "navigate",
+          "sec-fetch-site": "same-origin",
+          "sec-fetch-user": "?1",
+          "upgrade-insecure-requests": "1",
+          "viewport-width": "980",
+          cookie: "csrftoken=Ugye7fapneCzmN74O5UL0t; dpr=2.5506443977355957; mid=Z3PyVwABAAHxEqZRd-JfL7cYG2Ch; ig_did=A2C375D0-66A4-461E-8947-0AEB57237C37; ig_nrcb=1; datr=V_JzZ0dn4ZO1qbuoVydc7Gcp; wd=423x804",
+        },
+        referrerPolicy: "strict-origin-when-cross-origin",
+        body: null,
+        method: "GET",
+      })
+    ).text();
+
+    const form = new Form();
+    form.append("url", q);
+
+    const response = await axios({
+      url: "https://snapsave.app/id/action.php?lang=id",
+      method: "POST",
+      data: form,
+    });
+
+    const data = response.data;
+    const isEncodedHtml = data.includes("decodeURIComponent(escape(r))}(");
+    const encodedHtml = isEncodedHtml
+      ? data
+          .split("decodeURIComponent(escape(r))}(")[1]
+          .split("))")[0]
+          .split(",")
+          .map((v) => v.replace(/"/g, "").trim())
+      : null;
+
+    const decoded = isEncodedHtml ? extractInnerHtml(decode(encodedHtml)) : data.data;
+    const html = isEncodedHtml ? decoded : data;
+    if (!html) throw new Error("Tidak ada konten HTML yang ditemukan");
+
+    const $ = cheerio.load(html);
+    const $$ = cheerio.load(kontenInstagram);
+    const konten = [];
+
+    const metaDescription = $$('meta[name="description"]').attr("content");
+    const likesMatch = metaDescription?.match(/(\d+)\s+likes/);
+    const commentsMatch = metaDescription?.match(/(\d+)\s+comments/);
+
+    const likes = likesMatch ? likesMatch[1] : "N/A";
+    const comments = commentsMatch ? commentsMatch[1] : "N/A";
+
+    const imageUrl = $$('meta[name="twitter:image"]').attr("content");
+    const postUrl = $$('link[rel="alternate"][hreflang="x-default"]').attr("href");
+    const description = $$('meta[property="og:description"]').attr("content");
+    const postTimePattern = /on\s([^:]+):/;
+    const titlePattern = /:\s"([^"]+)"/;
+    const type = getType(q);
+    const postTimeMatch = description ? description.match(postTimePattern) : null;
+    const titleMatch = description ? description.match(titlePattern) : null;
+    const postingTime = postTimeMatch ? postTimeMatch[1] : null;
+    const title = titleMatch ? titleMatch[1] : null;
+    const accountName = getUsername(q) || description?.split("comments - ")[1]?.split(" on")[0];
+    const userInfo = accountName ? await getUserInfo(accountName) : {};
+    let avatarUrl = "";
+
+    $(".download-items").each((i, element) => {
+      const thumbElement = $(element).find(".download-items__thumb img");
+      const type = thumbElement
+        .siblings(".format-icon")
+        .find("i")
+        .hasClass("icon-dlvideo")
+        ? "video"
+        : "image";
+      const thumbnail =
+        $(element).find(".download-items__thumb img").attr("data-src") ||
+        $(element).find(".download-items__thumb img").attr("src");
+      const url = $(element).find(".download-items__btn a").attr("href");
+      let av =
+        $(element).find('.download-items__btn a[title="Download Avatar"]').attr("href") ||
+        $(element).find('.download-items__btn a[title="Unduh Avatar"]').attr("href");
+      if (av) {
+        avatarUrl = av;
+        return;
+      }
+      if (url) {
+        konten.push({ type, thumbnail, url });
+      }
+    });
+
+    return {
+      type,
+      title,
+      likes,
+      comments,
+      accountName,
+      avatarUrl,
+      imageUrl,
+      postUrl,
+      postingTime,
+      userInfo,
+      konten,
+    };
+  } catch {
+    return null;
+  }
+}
+
+module.exports = instagram;

scrape/tiktok.js

@@ -0,0 +1,197 @@
+const axios = require("axios");
+
+function extractJSONObject(str, startIndex) {
+    let openBraces = 0;
+    let inString = false;
+    let escapeNext = false;
+    let endIndex = startIndex;
+    for (; endIndex < str.length; endIndex++) {
+        const char = str[endIndex];
+        if (escapeNext) {
+            escapeNext = false;
+            continue;
+        }
+        if (char === "\\") {
+            escapeNext = true;
+            continue;
+        }
+        if (char === "\"") {
+            inString = !inString;
+        }
+        if (!inString) {
+            if (char === "{") openBraces++;
+            else if (char === "}") {
+                openBraces--;
+                if (openBraces === 0) {
+                    return str.substring(startIndex, endIndex + 1);
+                }
+            }
+        }
+    }
+    throw new Error("Gagal menemukan akhir JSON.");
+}
+
+async function resolveTikTokUrl(url) {
+    try {
+        const response = await axios.get(url, {
+            maxRedirects: 0,
+            validateStatus: status => status >= 300 && status < 400,
+        });
+        if (response.headers.location) {
+            return new URL(response.headers.location, url).href;
+        }
+    } catch (err) {
+        if (err.response && err.response.status === 302 && err.response.headers.location) {
+            return err.response.headers.location;
+        }
+    }
+    const response = await axios.get(url, {
+        maxRedirects: 20,
+        validateStatus: () => true
+    });
+    return response.request.res.responseUrl || url;
+}
+
+function formatOutput(title, data) {
+    return `\n=== ${title} ===\n${JSON.stringify(data, null, 2)}`;
+}
+
+const COMMON_HEADERS = {
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.9",
+    "Accept-Encoding": "gzip, deflate, br",
+    "Connection": "keep-alive",
+    "Sec-Fetch-Dest": "document",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": "none",
+    "Sec-Fetch-User": "?1",
+    "Upgrade-Insecure-Requests": "1",
+    "Cache-Control": "max-age=0",
+};
+
+async function getTikTokHtml(url) {
+    const resolvedUrl = await resolveTikTokUrl(url);
+    const isVideo = resolvedUrl.includes('/video/');
+    const isSlide = resolvedUrl.includes('/photo/') || resolvedUrl.includes('/image/');
+    const headers = {
+        ...COMMON_HEADERS,
+        "User-Agent": isVideo 
+            ? "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36"
+            : "Mozilla/5.0 (Linux; Android 14; CPH2641) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.7049.111 Mobile Safari/537.36",
+        "Referer": "https://www.tiktok.com/",
+    };
+    const response = await axios.get(resolvedUrl, { 
+        headers,
+        validateStatus: () => true
+    });
+    return {
+        html: response.data,
+        isVideo,
+        isSlide,
+        resolvedUrl
+    };
+}
+
+async function extractTikTokData(url) {
+    try {
+        const { html, isVideo, isSlide, resolvedUrl } = await getTikTokHtml(url);
+        let jsonKey, result;
+        if (isVideo) {
+            jsonKey = "\"webapp.video-detail\":";
+            const index = html.indexOf(jsonKey);
+            if (index === -1) throw new Error("Data video tidak ditemukan.");
+            const start = html.indexOf("{", index + jsonKey.length);
+            const jsonStr = extractJSONObject(html, start);
+            const jsonData = JSON.parse(jsonStr);
+            const item = jsonData?.itemInfo?.itemStruct;
+            if (!item) throw new Error("ItemStruct tidak ditemukan.");
+            result = {
+                type: "video",
+                url: resolvedUrl,
+                description: item.desc,
+                createTime: item.createTime,
+                video: item.video,
+                author: item.author,
+                music: item.music,
+                stats: item.stats,
+            };
+            console.log(formatOutput("Video TikTok", result));
+        } else if (isSlide) {
+            jsonKey = "\"webapp.reflow.video.detail\":";
+            const index = html.indexOf(jsonKey);
+            if (index === -1) throw new Error("Data slide tidak ditemukan.");
+            const start = html.indexOf("{", index + jsonKey.length);
+            const jsonStr = extractJSONObject(html, start);
+            const jsonData = JSON.parse(jsonStr);
+            const item = jsonData?.itemInfo?.itemStruct;
+            if (!item) throw new Error("ItemStruct tidak ditemukan.");
+            result = {
+                type: "slide",
+                url: resolvedUrl,
+                description: item.desc,
+                createTime: item.createTime,
+                images: item.imagePost?.images?.map(img => ({
+                    url: img.imageURL?.urlList?.[0] || null,
+                    width: img.imageWidth,
+                    height: img.imageHeight,
+                })),
+                author: item.author,
+                music: item.music,
+                stats: item.stats,
+            };
+            console.log(formatOutput("Slide TikTok", result));
+        } else {
+            const videoIndex = html.indexOf("\"webapp.video-detail\":");
+            const slideIndex = html.indexOf("\"webapp.reflow.video.detail\":");
+            if (videoIndex !== -1) {
+                jsonKey = "\"webapp.video-detail\":";
+                const start = html.indexOf("{", videoIndex + jsonKey.length);
+                const jsonStr = extractJSONObject(html, start);
+                const jsonData = JSON.parse(jsonStr);
+                const item = jsonData?.itemInfo?.itemStruct;
+                if (!item) throw new Error("ItemStruct tidak ditemukan.");
+                result = {
+                    type: "video",
+                    url: resolvedUrl,
+                    description: item.desc,
+                    createTime: item.createTime,
+                    video: item.video,
+                    author: item.author,
+                    music: item.music,
+                    stats: item.stats,
+                };
+                console.log(formatOutput("Video TikTok", result));
+            } else if (slideIndex !== -1) {
+                jsonKey = "\"webapp.reflow.video.detail\":";
+                const start = html.indexOf("{", slideIndex + jsonKey.length);
+                const jsonStr = extractJSONObject(html, start);
+                const jsonData = JSON.parse(jsonStr);
+                const item = jsonData?.itemInfo?.itemStruct;
+                if (!item) throw new Error("ItemStruct tidak ditemukan.");
+                result = {
+                    type: "slide",
+                    url: resolvedUrl,
+                    description: item.desc,
+                    createTime: item.createTime,
+                    images: item.imagePost?.images?.map(img => ({
+                        url: img.imageURL?.urlList?.[0] || null,
+                        width: img.imageWidth,
+                        height: img.imageHeight,
+                    })),
+                    author: item.author,
+                    music: item.music,
+                    stats: item.stats,
+                };
+                console.log(formatOutput("Slide TikTok", result));
+            } else {
+                throw new Error("URL tidak dikenali sebagai video atau slide TikTok dan tidak ditemukan data di HTML.");
+            }
+        }
+        return result;
+    } catch (err) {
+        console.error("❌ Gagal mengambil data:", err.message);
+        throw err;
+    }
+}
+
+module.exports = extractTikTokData;

scrape/tiktokdl.js

@@ -0,0 +1,191 @@
+// extractAndDownloadTikTok.js
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+const { pipeline } = require('stream/promises');
+const extractTikTokData = require('../scrape/tiktok'); // ✅ tanpa .cjs, otomatis kebaca
+
+const DOWNLOAD_FOLDER = path.join(__dirname, '../downloads');
+
+if (!fs.existsSync(DOWNLOAD_FOLDER)) {
+  fs.mkdirSync(DOWNLOAD_FOLDER, { recursive: true });
+}
+
+async function downloadMedia(url, outputPath, type = 'file') {
+  console.log(`Downloading ${type} from: ${url}`);
+  
+  const response = await axios({
+    method: "GET",
+    url,
+    responseType: "stream",
+    headers: {
+      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+      "Referer": "https://www.tiktok.com/",
+      "Origin": "https://www.tiktok.com",
+      "Accept": "*/*",
+      "Accept-Encoding": "identity"
+    },
+    timeout: 60000
+  });
+
+  if (response.status !== 200) {
+    throw new Error(`Failed to download ${type}: Status ${response.status}`);
+  }
+
+  const writer = fs.createWriteStream(outputPath);
+  await pipeline(response.data, writer);
+  
+  if (!fs.existsSync(outputPath)) {
+    throw new Error(`File ${type} not created`);
+  }
+  
+  const stats = fs.statSync(outputPath);
+  if (stats.size === 0) {
+    fs.unlinkSync(outputPath);
+    throw new Error(`File ${type} is empty (0 bytes)`);
+  }
+  
+  return stats;
+}
+
+function getVideoUrl(videoData) {
+  const bitrate = videoData?.bitrateInfo?.[0];
+  const uri = bitrate?.PlayAddr?.Uri || videoData?.uri;
+  const urlList = bitrate?.PlayAddr?.UrlList || videoData?.playAddr?.UrlList || [];
+  const finalUrl = urlList.find(url => url.includes(uri)) || urlList[0];
+  
+  if (!finalUrl) throw new Error("Video URL not found");
+  return finalUrl;
+}
+
+async function extractAndDownloadTikTok(url, domain) {
+  try {
+    const data = await extractTikTokData(url);
+    const { author, stats, video, music, type, description, images, resolvedUrl } = data;
+    
+    const folderName = `tiktok_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+    const downloadFolder = path.join(DOWNLOAD_FOLDER, folderName);
+    fs.mkdirSync(downloadFolder, { recursive: true });
+
+    const caption = `🔹 Username: ${author.uniqueId}\n` +
+      `🔹 Nickname: ${author.nickname}\n` +
+      `🔹 Description: ${description}\n` +
+      `❤️ Likes: ${stats.diggCount} | ` +
+      `💬 Comments: ${stats.commentCount} | ` +
+      `🔄 Shares: ${stats.shareCount}\n` +
+      `🎵 Music: ${music?.title || "-"}`;
+
+    if (type === "video") {
+      const videoUrl = getVideoUrl(video);
+      const videoFilename = `video.mp4`;
+      const videoPath = path.join(downloadFolder, videoFilename);
+      
+      await downloadMedia(videoUrl, videoPath, 'video');
+      
+      let musicInfo = null;
+      if (music?.playUrl) {
+        try {
+          const musicFilename = `music.mp3`;
+          const musicPath = path.join(downloadFolder, musicFilename);
+          await downloadMedia(music.playUrl, musicPath, 'music');
+          musicInfo = {
+            filename: musicFilename,
+            filePath: musicPath,
+            download_url: `${domain}/download/${folderName}/${musicFilename}`
+          };
+        } catch (err) {
+          console.error('Failed to download music:', err);
+        }
+      }
+
+      return {
+        success: true,
+        type: "video",
+        originalUrl: url,
+        resolvedUrl,
+        description,
+        createTime: data.createTime,
+        author,
+        music,
+        stats,
+        downloadInfo: {
+          success: true,
+          filename: videoFilename,
+          filePath: videoPath,
+          download_url: `${domain}/download/${folderName}/${videoFilename}`,
+          music: musicInfo,
+          folder_url: `${domain}/download/${folderName}`
+        },
+        caption
+      };
+    } 
+    else if (type === "slide") {
+      const downloadResults = [];
+      
+      for (let i = 0; i < images.length; i++) {
+        try {
+          const img = images[i];
+          const imgFilename = `slide_${i+1}.jpg`;
+          const imgPath = path.join(downloadFolder, imgFilename);
+          
+          await downloadMedia(img.url, imgPath, 'image');
+          
+          downloadResults.push({
+            success: true,
+            index: i+1,
+            filename: imgFilename,
+            filePath: imgPath,
+            download_url: `${domain}/download/${folderName}/${imgFilename}`
+          });
+        } catch (err) {
+          downloadResults.push({
+            success: false,
+            index: i+1,
+            error: err.message
+          });
+        }
+      }
+
+      let musicInfo = null;
+      if (music?.playUrl) {
+        try {
+          const musicFilename = `music.mp3`;
+          const musicPath = path.join(downloadFolder, musicFilename);
+          await downloadMedia(music.playUrl, musicPath, 'music');
+          musicInfo = {
+            filename: musicFilename,
+            filePath: musicPath,
+            download_url: `${domain}/download/${folderName}/${musicFilename}`
+          };
+        } catch (err) {
+          console.error('Failed to download music:', err);
+        }
+      }
+
+      return {
+        success: true,
+        type: "slide",
+        originalUrl: url,
+        resolvedUrl,
+        description,
+        createTime: data.createTime,
+        author,
+        music,
+        stats,
+        images: downloadResults,
+        musicInfo,
+        folder_url: `${domain}/download/${folderName}`,
+        caption
+      };
+    }
+  } catch (error) {
+    console.error('Error in TikTok download:', error);
+    return {
+      success: false,
+      error: error.message,
+      details: error.stack
+    };
+  }
+}
+
+module.exports = extractAndDownloadTikTok;