Upload 38 files

.dockerignore

@@ -0,0 +1,4 @@
+node_modules
+npm-debug.log
+.env
+.env.*

.env.production

@@ -0,0 +1,18 @@
+ACME_DOMAIN=
+ACME_EMAIL=
+INSTALL_TYPE=3
+LOCALTUNNEL=
+JACKETT_URL=http://jackett:9117
+JACKETT_API_KEY=0rnk28cvqd1esg4uzk2jrfjvm3zqealy
+PORT=4000
+DEFAULT_QUALITIES=0, 720, 1080, 2160
+DEFAULT_MAX_TORRENTS=15
+DEFAULT_PRIOTIZE_PACK_TORRENTS=2
+DEFAULT_FORCE_CACHE_NEXT_EPISODE=true
+DEFAULT_SORT_CACHED=quality:true, size:true
+DEFAULT_SORT_UNCACHED=seeders:true
+DEFAULT_HIDE_UNCACHED=true
+DEFAULT_INDEXERS=all
+DEFAULT_INDEXER_TIMEOUT_SEC=60
+COMPOSE_FILE=docker-compose.yml
+

Dockerfile

@@ -0,0 +1,18 @@
+FROM node:20-slim
+
+RUN mkdir -p /home/node/app && chown -R node:node /home/node/app \
+  && mkdir -p /data && chown -R node:node /data
+
+WORKDIR /home/node/app
+
+COPY --chown=node:node package*.json ./
+
+USER node
+
+RUN npm install
+
+COPY --chown=node:node ./src ./src
+
+EXPOSE 4000
+
+CMD [ "node", "src/index.js" ]

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

cli.sh

@@ -0,0 +1,295 @@
+#!/bin/bash
+
+set -e
+
+# Check if docker is installed
+if ! command -v docker >/dev/null 2>&1; then
+    echo "Error: Docker is not installed on this machine."
+    echo "https://www.docker.com/products/docker-desktop/"
+    exit 1
+fi
+
+if ! command -v curl >/dev/null 2>&1; then
+    apt-get update && apt-get install curl -y
+fi
+
+COMMAND="$1"
+RAW_GITHUB_URL="https://raw.githubusercontent.com/arvida42/jackettio/master"
+DIR=$(dirname "$0")
+ENV_FILE="$DIR/.env.production"
+JACKETT_PASSWORD=""
+
+ACME_DOMAIN=""
+ACME_EMAIL=""
+INSTALL_TYPE=""
+LOCALTUNNEL=""
+JACKETT_URL="http://jackett:9117"
+JACKETT_API_KEY=""
+PORT=4000
+COMPOSE_FILE=""
+
+cd $DIR
+
+importConfig() {
+    if [ ! -f "$ENV_FILE" ]; then
+        echo "Configuration file not found: $ENV_FILE"
+        echo "Are you in the corect folder to run this command ?"
+        exit 1
+    fi
+    source $ENV_FILE
+}
+
+runDockerCompose() {
+    docker compose -f docker-compose.yml -f $COMPOSE_FILE --env-file $ENV_FILE "$@"
+}
+
+downloadComposeFiles() {
+    echo "Downloading compose files ..."
+    curl -fsSL "${RAW_GITHUB_URL}/docker-compose.yml" -o docker-compose.yml
+    curl -fsSL "${RAW_GITHUB_URL}/${COMPOSE_FILE}" -o $COMPOSE_FILE
+}
+
+sedReplace(){
+    if [[ "$OSTYPE" == darwin* ]]; then
+        sed -i '' "$@"
+    else
+        sed -i "$@"
+    fi
+}
+
+createJackettPassword(){
+
+    FILE=$1
+    JACKETT_API_KEY=$(sed -n 's/.*"APIKey": "\(.*\)",/\1/p' $FILE)
+
+    if command -v openssl &> /dev/null; then
+        echo " - Generate password using openssl"
+        JACKETT_PASSWORD=$(openssl rand -base64 12)
+    else
+        echo " - Generate password using /dev/urandom "
+        JACKETT_PASSWORD=$(tr -dc A-Za-z0-9_ < /dev/urandom | head -c 12)
+    fi
+
+    echo " - Create password hash ..."
+    # https://github.com/Jackett/Jackett/blob/d560175c20a64c0d5379ceb7178810d00b71498d/src/Jackett.Server/Services/SecurityService.cs#L26
+    NODE_COMMAND="node -e \"const crypto = require('crypto');
+    const input = '${JACKETT_PASSWORD}${JACKETT_API_KEY}';
+    const hash = crypto.createHash('sha512');
+    hash.update(Buffer.from(input, 'utf16le'));
+    console.log(hash.digest().toString('hex'));\""
+    JACKETT_PASSWORD_HASH=$(docker run --rm node:20-slim sh -c "$NODE_COMMAND")
+
+    sedReplace 's/"AdminPassword": .*,/"AdminPassword": "'"$JACKETT_PASSWORD_HASH"'",/' $FILE
+
+}
+
+showHelp(){
+    cat <<-END
+
+Usage: sh ./cli.sh [command]
+
+Available commands:
+
+    start               Start all containers
+    stop                Stop all containers
+    down                Stop and remove all containers
+    update              Update all containers
+    install             Install and configure all containers
+    jackett-password    Reset jackett password
+
+END
+}
+
+# Store information in an environment file
+saveConfig() {
+cat <<EOF > $ENV_FILE
+ACME_DOMAIN=$ACME_DOMAIN
+ACME_EMAIL=$ACME_EMAIL
+INSTALL_TYPE=$INSTALL_TYPE
+LOCALTUNNEL=$LOCALTUNNEL
+JACKETT_URL=$JACKETT_URL
+JACKETT_API_KEY=$JACKETT_API_KEY
+PORT=$PORT
+COMPOSE_FILE=$COMPOSE_FILE
+EOF
+}
+
+case "$COMMAND" in
+    "--help"|"help")
+        showHelp
+        exit 0
+        ;;
+    "start")
+        importConfig
+        runDockerCompose up -d
+        exit 0
+        ;;
+    "stop" | "down")
+        importConfig
+        runDockerCompose $COMMAND
+        exit 0
+        ;;
+    "update")
+        importConfig
+        runDockerCompose down
+        downloadComposeFiles
+        runDockerCompose pull
+        runDockerCompose up -d
+        exit 0
+        ;;
+    "jackett-password")
+        importConfig
+        docker cp jackett:/config/Jackett/ServerConfig.json /tmp/ServerConfig.json > /dev/null
+        createJackettPassword /tmp/ServerConfig.json
+        docker cp /tmp/ServerConfig.json jackett:/config/Jackett/ServerConfig.json > /dev/null
+        rm -f /tmp/ServerConfig.json
+        echo "Restart jackett ..."
+        docker restart jackett
+        echo "Your new password is: $JACKETT_PASSWORD"
+        echo "Please change it for security in jackett dashboard"
+        exit 0
+        ;;
+    "install")
+        echo "Install ..."
+        ;;
+    *)
+         echo -e "\033[0;31mInvalid command: ${COMMAND}\033[0m"
+        showHelp
+        exit 1
+        ;;
+esac
+
+if [ -f "$ENV_FILE" ]; then
+    echo -e "\033[0;31mAn installation appears to already exist and will be overwritten ! ($ENV_FILE)\033[0m"
+    read -p "  Continue and overwrite ? (y/n): " continue
+    if [[ $continue != "yes" && $continue != "y" ]]; then
+        echo "Exiting..."
+        exit
+    fi
+fi
+
+cat <<-END
+
+This script will install compose and environments file in the following folder
+-----------------------
+${PWD}
+-----------------------
+END
+read -p "Are you sure you want to continue? (y/n): " continue
+if [[ $continue != "yes" && $continue != "y" ]]; then
+    echo "Exiting..."
+    exit
+fi
+
+cat <<-END
+
+Please select an installation type:
+
+    1) Using traefik
+       You must have a domain configured for this machine, ports 80 and 443 must be opened.
+       Your Addon will be available on the address: https://your_domain
+
+    2) Using localtunnel
+       This installation use "localtunnel" to expose the app on Internet.
+       There's no need to configure a domain; you can run it directly on your local machine.
+       However, you may encounter limitations imposed by LocalTunnel.
+       All requests from the addons will go through LocalTunnel.
+       Your Addon will be available on the address: https://random-id.localtunnel.me
+
+    3) Local
+       Install locally without domain. Stremio App must run in same machine to works.
+       Your Addon will be available on the address: http://localhost
+
+END
+
+read -p "Please chose 1,2 or 3): " INSTALL_TYPE
+
+case "$INSTALL_TYPE" in
+    "1")
+        echo "traefik selected"
+        read -p "Please enter your domain name (example.com): " ACME_DOMAIN
+        read -p "Please enter your email (email@example.com): " ACME_EMAIL
+        COMPOSE_FILE=docker-compose-traefik.yml
+        echo "Your domain: ${ACME_DOMAIN}"
+        echo "Your email: ${ACME_EMAIL}"
+        ;;
+    "2")
+        echo "localtunnel selected"
+        COMPOSE_FILE=docker-compose-tunnel.yml
+        LOCALTUNNEL="true"
+        ;;
+    "3")
+        echo "local selected"
+        COMPOSE_FILE=docker-compose-local.yml
+        ;;
+    *)
+        echo "Invalid installation type: ${INSTALL_TYPE}"
+        echo "Must be 1,2 or 3"
+        exit 1
+        ;;
+esac
+
+saveConfig
+echo "------------------"
+cat $ENV_FILE
+echo ""
+echo "Please confirm the above information before proceeding."
+read -p "Continue ? (y/n): " continue
+if [[ $continue != "yes" && $continue != "y" ]]; then
+    echo "Exiting..."
+    exit
+fi
+
+downloadComposeFiles
+
+echo "Configure jackett ..."
+runDockerCompose up -d jackett
+echo "Wait for jackett ..."
+sleep 6
+docker cp jackett:/config/Jackett/ServerConfig.json /tmp/ServerConfig.json > /dev/null
+JACKETT_API_KEY=$(sed -n 's/.*"APIKey": "\(.*\)",/\1/p' /tmp/ServerConfig.json)
+JACKETT_PASSWORD_HASH=$(sed -n 's/.*"AdminPassword": "\(.*\)",/\1/p' /tmp/ServerConfig.json)
+
+if [ -z "$JACKETT_PASSWORD_HASH" ]; then
+    echo " - Configure jackett admin password ..."
+    createJackettPassword /tmp/ServerConfig.json
+fi
+
+echo " - Configure jackett flaresolverr url ..."
+sedReplace 's/"FlareSolverrUrl": .*,/"FlareSolverrUrl": "http:\/\/flaresolverr:8191",/' /tmp/ServerConfig.json
+docker cp /tmp/ServerConfig.json jackett:/config/Jackett/ServerConfig.json > /dev/null
+rm -f /tmp/ServerConfig.json
+runDockerCompose down
+
+saveConfig
+
+echo "Start all containers ..."
+runDockerCompose up -d
+
+
+echo "-----------------------"
+
+
+echo -e "\n\033[0;32mInstallation complete! \033[0m\n"
+case "$INSTALL_TYPE" in
+    "1")
+        echo " - Your addon is available on the following address: https://${ACME_DOMAIN}/configure"
+        ;;
+    "2")
+        echo "Wait for Jackettio ..."
+        sleep 4
+        runDockerCompose logs -n 30 jackettio
+        ;;
+    "3")
+        echo " - Your addon is available on the following address: http://localhost:4000/configure"
+        ;;
+esac
+
+echo " - Your Jackett instance to configure your trackers is available on the following address: http://localhost:9117 or http://${ACME_DOMAIN:-your_public_ip}:9117"
+echo "   Be aware that having a lot of trackers may slow down search queries within the addon. We recommend utilizing trackers that do not have Cloudflare protection."
+
+if [ ! -z "$JACKETT_PASSWORD" ]; then
+    echo -e "\n - \033[0;31mIMPORTANT:\033[0m The default password for Jackett is \"${JACKETT_PASSWORD}\", Please change it for security in jackett dashboard."
+fi
+
+echo "-----------------------"

docker-compose-local.yml

@@ -0,0 +1,11 @@
+version: "3.3"
+
+services:
+
+  jackettio:
+    ports:
+      - 4000:4000
+
+  jackett:
+    ports:
+      - 9117:9117

docker-compose-traefik.yml

@@ -0,0 +1,49 @@
+version: "3.3"
+
+services:
+
+  jackettio:
+    labels:
+      - "traefik.enable=true"
+      - "traefik.docker.network=jackettio_traefik"
+      - "traefik.http.routers.jackettio.entrypoints=web,websecure"
+      - "traefik.http.routers.jackettio.rule=Host(`${ACME_DOMAIN:-}`)"
+      - "traefik.http.routers.jackettio.tls=true"
+      - "traefik.http.routers.jackettio.tls.certresolver=letsencryptresolver"
+    networks:
+      - traefik
+
+  jackett:
+    ports:
+      - 9117:9117
+
+  traefik:
+    image: "traefik:v2.10"
+    container_name: "traefik"
+    command:
+      #- "--log.level=DEBUG"
+      - "--api.insecure=true"
+      - "--providers.docker=true"
+      - "--providers.docker.exposedbydefault=false"
+      - "--entrypoints.web.address=:80"
+      - "--entrypoints.websecure.address=:443"
+      - "--certificatesresolvers.letsencryptresolver.acme.httpchallenge=true"
+      - "--certificatesresolvers.letsencryptresolver.acme.httpchallenge.entrypoint=web"
+      - "--certificatesresolvers.letsencryptresolver.acme.email=${ACME_EMAIL:-}"
+      - "--certificatesresolvers.letsencryptresolver.acme.storage=/letsencrypt/acme.json"
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      # To persist certificates
+      - letsencrypt:/letsencrypt
+      # So that Traefik can listen to the Docker events
+      - "/var/run/docker.sock:/var/run/docker.sock:ro"
+    networks:
+      - traefik
+
+networks:
+  traefik:
+
+volumes:
+  letsencrypt:

docker-compose-tunnel.yml

@@ -0,0 +1,7 @@
+version: "3.3"
+
+services:
+
+  jackett:
+    ports:
+      - 9117:9117

docker-compose.yml

@@ -0,0 +1,62 @@
+version: "3.3"
+name: jackettio
+services:
+
+  flaresolverr:
+    image: ghcr.io/flaresolverr/flaresolverr:latest
+    container_name: flaresolverr
+    environment:
+      - LOG_LEVEL=${LOG_LEVEL:-info}
+      - LOG_HTML=${LOG_HTML:-false}
+      - CAPTCHA_SOLVER=${CAPTCHA_SOLVER:-none}
+    networks:
+      - jackettio
+    ports:
+      - "8191:8191"  # FlareSolverr default port
+    restart: unless-stopped
+
+  jackett:
+    image: lscr.io/linuxserver/jackett:latest
+    container_name: jackett
+    environment:
+      - AUTO_UPDATE=true #optional
+      - RUN_OPTS= #optional
+    depends_on:
+      - flaresolverr
+    networks:
+      - jackettio
+    ports:
+      - "9117:9117"  # Jackett default port
+    restart: unless-stopped
+    volumes:
+      - jackett-config:/config
+      - jackett-downloads:/downloads
+
+  jackettio:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: jackettio
+    env_file:
+      - .env.production
+    environment:
+      - NODE_ENV=production
+      - DATA_FOLDER=/data
+    depends_on:
+      - jackett
+    networks:
+      - jackettio
+    ports:
+      - "4000:4000"  # Jackettio port
+    restart: unless-stopped
+    volumes:
+      - ./:/app  # Mount the current directory to /app in the container
+      - jackettio-data:/data
+
+networks:
+  jackettio:
+
+volumes:
+  jackett-config:
+  jackett-downloads:
+  jackettio-data:

package.json

@@ -0,0 +1,29 @@
+{
+  "name": "jackettio",
+  "version": "1.6.0",
+  "description": "Jackett and Debrid on Stremio",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node src/index.js"
+  },
+  "keywords": [
+    "stremio",
+    "stremio-addons",
+    "addons"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "cache-manager": "^4.1.0",
+    "cache-manager-sqlite": "^0.2.0",
+    "compression": "^1.7.4",
+    "express": "^4.18.2",
+    "express-rate-limit": "^7.2.0",
+    "localtunnel": "^2.0.2",
+    "p-limit": "^5.0.0",
+    "parse-torrent": "^11.0.16",
+    "showdown": "^2.1.0",
+    "sqlite3": "^5.1.1",
+    "xml2js": "^0.6.2"
+  }
+}

src/index.js

@@ -0,0 +1,289 @@
+import showdown from 'showdown';
+import compression from 'compression';
+import express from 'express';
+import localtunnel from 'localtunnel';
+import { rateLimit } from 'express-rate-limit';
+import {readFileSync} from "fs";
+import config from './lib/config.js';
+import cache, {vacuum as vacuumCache, clean as cleanCache} from './lib/cache.js';
+import path from 'path';
+import * as meta from './lib/meta.js';
+import * as icon from './lib/icon.js';
+import * as debrid from './lib/debrid.js';
+import {getIndexers} from './lib/jackett.js';
+import * as jackettio from "./lib/jackettio.js";
+import {cleanTorrentFolder, createTorrentFolder} from './lib/torrentInfos.js';
+
+const converter = new showdown.Converter();
+const welcomeMessageHtml = config.welcomeMessage ? `${converter.makeHtml(config.welcomeMessage)}<div class="my-4 border-top border-secondary-subtle"></div>` : '';
+const addon = JSON.parse(readFileSync(`./package.json`));
+const app = express();
+
+const respond = (res, data) => {
+  res.setHeader('Access-Control-Allow-Origin', '*')
+  res.setHeader('Access-Control-Allow-Headers', '*')
+  res.setHeader('Content-Type', 'application/json')
+  res.send(data)
+};
+
+const limiter = rateLimit({
+  windowMs: config.rateLimitWindow * 1000,
+  max: config.rateLimitRequest,
+  legacyHeaders: false,
+  standardHeaders: 'draft-7',
+  keyGenerator: (req) => req.clientIp || req.ip,
+  handler: (req, res, next, options) => {
+    if(req.route.path == '/:userConfig/stream/:type/:id.json'){
+      const resetInMs = new Date(req.rateLimit.resetTime) - new Date();
+      return res.json({streams: [{
+        name: `${config.addonName}`,
+        title: `🛑 Too many requests, please try in ${Math.ceil(resetInMs / 1000 / 60)} minute(s).`,
+        url: '#'
+      }]})
+    }else{
+      return res.status(options.statusCode).send(options.message);
+    }
+  }
+});
+
+app.set('trust proxy', config.trustProxy);
+
+app.use((req, res, next) => {
+  req.clientIp = req.ip;
+  if(req.get('CF-Connecting-IP')){
+    req.clientIp = req.get('CF-Connecting-IP');
+  }
+  next();
+});
+
+app.use(compression());
+app.use(express.static(path.join(import.meta.dirname, 'static'), {maxAge: 86400e3}));
+
+app.get('/', (req, res) => {
+  res.redirect('/configure')
+  res.end();
+});
+
+app.get('/icon', async (req, res) => {
+  const filePath = await icon.getLocation();
+  res.contentType(path.basename(filePath));
+  res.setHeader('Cache-Control', `public, max-age=${3600}`);
+  return res.sendFile(filePath);
+});
+
+app.use((req, res, next) => {
+  console.log(`${req.method} ${req.path.replace(/\/eyJ[\w\=]+/g, '/*******************')}`);
+  next();
+});
+
+app.get('/:userConfig?/configure', async(req, res) => {
+  let indexers = (await getIndexers().catch(() => []))
+    .map(indexer => ({
+      value: indexer.id, 
+      label: indexer.title, 
+      types: ['movie', 'series'].filter(type => indexer.searching[type].available)
+    }));
+  const templateConfig = {
+    debrids: await debrid.list(),
+    addon: {
+      version: addon.version,
+      name: config.addonName
+    },
+    userConfig: req.params.userConfig || '',
+    defaultUserConfig: config.defaultUserConfig,
+    qualities: config.qualities,
+    languages: config.languages.map(l => ({value: l.value, label: l.label})).filter(v => v.value != 'multi'),
+    metaLanguages: await meta.getLanguages(),
+    sorts: config.sorts,
+    indexers,
+    passkey: {enabled: false},
+    immulatableUserConfigKeys: config.immulatableUserConfigKeys
+  };
+  if(config.replacePasskey){
+    templateConfig.passkey = {
+      enabled: true,
+      infoUrl: config.replacePasskeyInfoUrl,
+      pattern: config.replacePasskeyPattern
+    }
+  }
+  let template = readFileSync(`./src/template/configure.html`).toString()
+    .replace('/** import-config */', `const config = ${JSON.stringify(templateConfig, null, 2)}`)
+    .replace('<!-- welcome-message -->', welcomeMessageHtml);
+  return res.send(template);
+});
+
+// https://github.com/Stremio/stremio-addon-sdk/blob/master/docs/advanced.md#using-user-data-in-addons
+app.get("/:userConfig?/manifest.json", async(req, res) => {
+  const manifest = {
+    id: config.addonId,
+    version: addon.version,
+    name: config.addonName,
+    description: config.addonDescription,
+    icon: `${req.hostname == 'localhost' ? 'http' : 'https'}://${req.hostname}/icon`,
+    resources: ["stream"],
+    types: ["movie", "series"],
+    idPrefixes: ["tt","tmdb"],
+    catalogs: [],
+    behaviorHints: {configurable: true}
+  };
+  if(req.params.userConfig){
+    const userConfig = JSON.parse(atob(req.params.userConfig));
+    const debridInstance = debrid.instance(userConfig);
+    manifest.name += ` ${debridInstance.shortName}`;
+  }
+  respond(res, manifest);
+});
+
+app.get("/:userConfig/stream/:type/:id.json", limiter, async(req, res) => {
+
+  try {
+
+    const streams = await jackettio.getStreams(
+      Object.assign(JSON.parse(atob(req.params.userConfig)), {ip: req.clientIp}),
+      req.params.type, 
+      req.params.id,
+      `${req.hostname == 'localhost' ? 'http' : 'https'}://${req.hostname}`
+    );
+
+    return respond(res, {streams});
+
+  }catch(err){
+
+    console.log(req.params.id, err);
+    return respond(res, {streams: []});
+
+  }
+
+});
+
+app.get("/stream/:type/:id.json", async(req, res) => {
+
+  return respond(res, {streams: [{
+    name: config.addonName,
+    title: `ℹ Kindly configure this addon to access streams.`,
+    url: '#'
+  }]});
+
+});
+
+app.use('/:userConfig/download/:type/:id/:torrentId', async(req, res, next) => {
+
+  if (req.method !== 'GET' && req.method !== 'HEAD'){
+    return next();
+  }
+
+  try {
+
+    const url = await jackettio.getDownload(
+      Object.assign(JSON.parse(atob(req.params.userConfig)), {ip: req.clientIp}),
+      req.params.type, 
+      req.params.id, 
+      req.params.torrentId
+    );
+
+    const parsed = new URL(url);
+    const cut = (value) => value ?  `${value.substr(0, 5)}******${value.substr(-5)}` : '';
+    console.log(`${req.params.id} : Redirect: ${parsed.protocol}//${parsed.host}${cut(parsed.pathname)}${cut(parsed.search)}`);
+    
+    res.status(302);
+    res.set('location', url);
+    res.send('');
+
+  }catch(err){
+
+    console.log(req.params.id, err);
+
+    switch(err.message){
+      case debrid.ERROR.NOT_READY:
+        res.status(302);
+        res.set('location', `/videos/not_ready.mp4`);
+        res.send('');
+        break;
+      case debrid.ERROR.EXPIRED_API_KEY:
+        res.status(302);
+        res.set('location', `/videos/expired_api_key.mp4`);
+        res.send('');
+        break;
+      case debrid.ERROR.NOT_PREMIUM:
+        res.status(302);
+        res.set('location', `/videos/not_premium.mp4`);
+        res.send('');
+        break;
+      case debrid.ERROR.ACCESS_DENIED:
+        res.status(302);
+        res.set('location', `/videos/access_denied.mp4`);
+        res.send('');
+        break;
+      case debrid.ERROR.TWO_FACTOR_AUTH:
+        res.status(302);
+        res.set('location', `/videos/two_factor_auth.mp4`);
+        res.send('');
+        break;
+      default:
+        res.status(302);
+        res.set('location', `/videos/error.mp4`);
+        res.send('');
+    }
+
+  }
+
+});
+
+app.use((req, res) => {
+  if (req.xhr) {
+    res.status(404).send({ error: 'Page not found!' })
+  } else {
+    res.status(404).send('Page not found!');
+  }
+});
+
+app.use((err, req, res, next) => {
+  console.error(err.stack)
+  if (req.xhr) {
+    res.status(500).send({ error: 'Something broke!' })
+  } else {
+    res.status(500).send('Something broke!');
+  }
+})
+
+const server = app.listen(config.port, async () => {
+
+  console.log('───────────────────────────────────────');
+  console.log(`Started addon ${addon.name} v${addon.version}`);
+  console.log(`Server listen at: http://localhost:${config.port}`);
+  console.log('───────────────────────────────────────');
+
+  let tunnel;
+  if(config.localtunnel){
+    let subdomain = await cache.get('localtunnel:subdomain');
+    tunnel = await localtunnel({port: config.port, subdomain});
+    await cache.set('localtunnel:subdomain', tunnel.clientId, {ttl: 86400*365});
+    console.log(`Your addon is available on the following address: ${tunnel.url}/configure`);
+    tunnel.on('close', () => console.log("tunnels are closed"));
+  }
+
+  icon.download().catch(err => console.log(`Failed to download icon: ${err}`));
+
+  const intervals = [];
+  createTorrentFolder();
+  intervals.push(setInterval(cleanTorrentFolder, 3600e3));
+
+  vacuumCache().catch(err => console.log(`Failed to vacuum cache: ${err}`));
+  intervals.push(setInterval(() => vacuumCache(), 86400e3*7));
+
+  cleanCache().catch(err => console.log(`Failed to clean cache: ${err}`));
+  intervals.push(setInterval(() => cleanCache(), 3600e3));
+
+  function closeGracefully(signal) {
+    console.log(`Received signal to terminate: ${signal}`);
+    if(tunnel)tunnel.close();
+    intervals.forEach(interval => clearInterval(interval));
+    server.close(() => {
+      console.log('Server closed');
+      process.kill(process.pid, signal);
+    });
+  }
+  process.once('SIGINT', closeGracefully);
+  process.once('SIGTERM', closeGracefully);
+
+});

src/lib/cache.js

@@ -0,0 +1,35 @@
+import sqlite3 from 'sqlite3';
+import sqliteStore from 'cache-manager-sqlite';
+import cacheManager from 'cache-manager';
+import config from './config.js';
+import {wait} from './util.js';
+
+const db = new sqlite3.Database(`${config.dataFolder}/cache.db`);
+
+const cache = await cacheManager.caching({
+  store: sqliteStore,
+  path: `${config.dataFolder}/cache.db`,
+  options: { ttl: 86400 }
+});
+
+export default cache;
+
+export async function clean(){
+  // https://github.com/maxpert/node-cache-manager-sqlite/blob/36a1fe44a30b6af8d8c323c59e09fe81bde539d9/index.js#L146
+  // The cache will grow until an expired key is requested
+  // This hack should force node-cache-manager-sqlite to purge
+  await cache.set('_clean', 'todo', {ttl: 1});
+  await wait(3e3);
+  await cache.get('_clean');
+}
+
+export async function vacuum(){
+  return new Promise((resolve, reject) => {
+    db.serialize(() => {
+      db.run('VACUUM', err => {
+        if(err)return reject(err);
+        resolve();
+      })
+    });
+  });
+}

src/lib/config.js

@@ -0,0 +1,130 @@
+export default {
+  // Server port
+  port: parseInt(process.env.PORT || 4000),
+  // https://expressjs.com/en/guide/behind-proxies.html
+  trustProxy: boolOrString(process.env.TRUST_PROXY || 'loopback, linklocal, uniquelocal'),
+  // Jacket instance url
+  jackettUrl: process.env.JACKETT_URL || 'http://localhost:9117',
+  // Jacket API key
+  jackettApiKey: process.env.JACKETT_API_KEY || '',
+  //  The Movie Database Access Token. Configure to use TMDB rather than cinemeta.
+  tmdbAccessToken: process.env.TMDB_ACCESS_TOKEN || '96ca5e1179f107ab7af156b0a3ae9ca5', 
+  // Data folder for cache database, torrent files ... Must be persistent in production
+  dataFolder: process.env.DATA_FOLDER || '/tmp',
+  // Enable localtunnel feature
+  localtunnel: (process.env.LOCALTUNNEL || 'false') === 'true',
+  // Addon ID
+  addonId: process.env.ADDON_ID || 'community.stremio.jackettio',
+  // Addon Name
+  addonName: process.env.ADDON_NAME || 'TMDb UFC Jackettio',
+  // Addon Description
+  addonDescription: process.env.ADDON_DESCRIPTION || 'Stremio addon that resolve streams using Jackett and Debrid. It seamlessly integrates with private trackers.',
+  // Addon Icon
+  addonIcon: process.env.ADDON_ICON || 'https://avatars.githubusercontent.com/u/15383019?s=48&v=4',
+  // When hosting a public instance with a private tracker, you must configure this setting to:
+  // - Request the user's passkey on the /configure page.
+  // - Replace your passkey "REPLACE_PASSKEY" with theirs when sending uncached torrents to the debrid.
+  // If you do not configure this setting with private tracker, your passkey could be exposed to users who add uncached torrents.
+  replacePasskey: process.env.REPLACE_PASSKEY || '',
+  // The URL where the user can locate their passkey (typically the tracker URL).
+  replacePasskeyInfoUrl: process.env.REPLACE_PASSKEY_INFO_URL || '',
+  // The passkey pattern
+  replacePasskeyPattern: process.env.REPLACE_PASSKEY_PATTERN || '[a-zA-Z0-9]+',
+  // List of config keys that user can't configure
+  immulatableUserConfigKeys: commaListToArray(process.env.IMMULATABLE_USER_CONFIG_KEYS || 'hideUncached'),
+  // Welcome message in /configure page. Markdown format
+  welcomeMessage: process.env.WELCOME_MESSAGE || '',
+  // Trust the cf-connecting-ip header
+  trustCfIpHeader: (process.env.TRUST_CF_IP_HEADER || 'false') === 'true',
+  // Rate limit interval in seconds to resolve stream
+  rateLimitWindow: parseInt(process.env.RATE_LIMIT_WINDOW || 60 * 60),
+  // Rate limit the number of requests to resolve stream
+  rateLimitRequest: parseInt(process.env.RATE_LIMIT_REQUEST || 150),
+  // Time (in seconds) needed to identify an indexer as slow
+  slowIndexerDuration: parseInt(process.env.SLOW_INDEXER_DURATION || 20) * 1000,
+  // Time window (in seconds) to monitor and count slow indexer requests (only requests within this period are considered)
+  slowIndexerWindow: parseInt(process.env.SLOW_INDEXER_WINDOW || 1800) * 1000,
+  // Number of consecutive slow requests within the time window to disable the indexer
+  slowIndexerRequest: parseInt(process.env.SLOW_INDEXER_REQUEST || 5),
+
+  defaultUserConfig: {
+    qualities: commaListToArray(process.env.DEFAULT_QUALITIES || '0, 720, 1080, 2160').map(v => parseInt(v)),
+    excludeKeywords: commaListToArray(process.env.DEFAULT_EXCLUDE_KEYWORDS || ''),
+    maxTorrents: parseInt(process.env.DEFAULT_MAX_TORRENTS || 15),
+    priotizeLanguages: commaListToArray(process.env.DEFAULT_PRIOTIZE_LANGUAGES || ''),
+    priotizePackTorrents:  parseInt(process.env.DEFAULT_PRIOTIZE_PACK_TORRENTS || 2),
+    forceCacheNextEpisode: (process.env.DEFAULT_FORCE_CACHE_NEXT_EPISODE || 'false') === 'true',
+    sortCached: sortCommaListToArray(process.env.DEFAULT_SORT_CACHED || 'quality:true, size:true'),
+    sortUncached: sortCommaListToArray(process.env.DEFAULT_SORT_UNCACHED || 'seeders:true'),
+    hideUncached: true, // Force hideUncached to always be true
+    indexers: commaListToArray(process.env.DEFAULT_INDEXERS || 'all'),
+    indexerTimeoutSec: parseInt(process.env.DEFAULT_INDEXER_TIMEOUT_SEC || '60'),
+    passkey: '',
+    // If not defined, the original title is used for search. If defined, the title in the given language is used for search
+    // format: ISO 639-1, example: en
+    metaLanguage: process.env.DEFAULT_META_LANGUAGE || '',
+    enableMediaFlow: (process.env.DEFAULT_ENABLE_MEDIA_FLOW || 'false') === 'true',
+    mediaflowProxyUrl: process.env.DEFAULT_MEDIA_FLOW_PROXY_URL || '',
+    mediaflowApiPassword: process.env.DEFAULT_MEDIA_FLOW_API_PASSWORD || '',
+    mediaflowPublicIp: process.env.DEFAULT_MEDIA_FLOW_PUBLIC_IP || ''
+  },
+
+  qualities: [
+    {value: 0, label: 'Unknown'},
+    {value: 360, label: '360p'},
+    {value: 480, label: '480p'},
+    {value: 720, label: '720p'},
+    {value: 1080, label: '1080p'},
+    {value: 2160, label: '4K'}
+  ],
+  sorts: [
+    {value: [['quality', true], ['seeders', true]], label: 'By quality then seeders'},
+    {value: [['quality', true], ['size', true]], label: 'By quality then size'},
+    {value: [['seeders', true]], label: 'By seeders'},
+    {value: [['quality', true]], label: 'By quality'},
+    {value: [['size', true]], label: 'By size'}
+  ],
+  languages: [
+    {value: 'multi',      emoji: '🌎', iso639: '',   pattern: 'multi'},
+    {value: 'arabic',     emoji: '🇦🇪', iso639: 'ar', pattern: 'arabic'},
+    {value: 'chinese',    emoji: '🇨🇳', iso639: 'zh', pattern: 'chinese'},
+    {value: 'german',     emoji: '🇩🇪', iso639: 'de', pattern: 'german'},
+    {value: 'english',    emoji: '🇺🇸', iso639: 'en', pattern: '(eng(lish)?)'},
+    {value: 'spanish',    emoji: '🇪🇸', iso639: 'es', pattern: 'spa(nish)?'},
+    {value: 'french',     emoji: '🇫🇷', iso639: 'fr', pattern: 'fre(nch)?'},
+    {value: 'dutch',      emoji: '🇳🇱', iso639: 'nl', pattern: 'dutch'},
+    {value: 'italian',    emoji: '🇮🇹', iso639: 'it', pattern: 'ita(lian)?'},
+    {value: 'lithuanian', emoji: '🇱🇹', iso639: 'lt', pattern: 'lithuanian'},
+    {value: 'korean',     emoji: '🇰🇷', iso639: 'ko', pattern: 'korean'},
+    {value: 'portuguese', emoji: '🇵🇹', iso639: 'pt', pattern: 'portuguese'},
+    {value: 'russian',    emoji: '🇷🇺', iso639: 'ru', pattern: 'rus(sian)?'},
+    {value: 'swedish',    emoji: '🇸🇪', iso639: 'sv', pattern: 'swedish'},
+    {value: 'tamil',      emoji: '🇮🇳', iso639: 'ta', pattern: 'tamil'},
+    {value: 'turkish',    emoji: '🇹🇷', iso639: 'tr', pattern: 'turkish'}
+  ].map(lang => {
+    lang.label = `${lang.emoji} ${lang.value.charAt(0).toUpperCase() + lang.value.slice(1)}`;
+    lang.pattern = new RegExp(` ${lang.pattern} `, 'i');
+    return lang;
+  })
+}
+
+function commaListToArray(str){
+  return str.split(',').map(str => str.trim()).filter(Boolean);
+}
+
+function sortCommaListToArray(str){
+  return commaListToArray(str).map(sort => {
+    const [key, reverse] = sort.split(':');
+    return [key.trim(), reverse.trim() == 'true'];
+  });
+}
+
+function boolOrString(str){
+  if(str.trim().toLowerCase() == 'true'){
+    return true;
+  }else if(str.trim().toLowerCase() == 'false'){
+    return false;
+  }else{
+    return str.trim();
+  }
+}

src/lib/debrid.js

@@ -0,0 +1,28 @@
+import debridlink from "./debrid/debridlink.js";
+import alldebrid from "./debrid/alldebrid.js";
+import realdebrid from './debrid/realdebrid.js';
+export {ERROR} from './debrid/const.js';
+import premiumize from "./debrid/premiumize.js";
+const debrid = {debridlink, alldebrid, realdebrid, premiumize};
+
+export function instance(userConfig){
+
+  if(!debrid[userConfig.debridId]){
+    throw new Error(`Debrid service "${userConfig.debridId} not exists`);
+  }
+  
+  return new debrid[userConfig.debridId](userConfig);
+}
+
+export async function list(){
+  const values = [];
+  for(const instance of Object.values(debrid)){
+    values.push({
+      id: instance.id,
+      name: instance.name,
+      shortName: instance.shortName,
+      configFields: instance.configFields
+    })
+  }
+  return values;
+}

src/lib/debrid/alldebrid.js

@@ -0,0 +1,140 @@
+import {createHash} from 'crypto';
+import {ERROR} from './const.js';
+import {wait} from '../util.js';
+
+export default class AllDebrid {
+
+  static id = 'alldebrid';
+  static name = 'AllDebrid';
+  static shortName = 'AD';
+  static configFields = [
+    {
+      type: 'text', 
+      name: 'debridApiKey', 
+      label: `AllDebrid API Key`, 
+      required: true, 
+      href: {value: 'https://alldebrid.com/apikeys', label:'Get API Key Here'}
+    }
+  ];
+
+  #apiKey;
+  #ip;
+
+  constructor(userConfig) {
+    Object.assign(this, this.constructor);
+    this.#apiKey = userConfig.debridApiKey;
+    this.#ip = userConfig.ip || '';
+  }
+
+  async getTorrentsCached(torrents){
+    const hashList = torrents.map(torrent => torrent.infos.infoHash).filter(Boolean);
+    const body = new FormData();
+    hashList.forEach(hash => body.append('magnets[]', hash));
+    const res = await this.#request('POST', '/magnet/instant', {body});
+    return torrents.filter(torrent => res.data.magnets.find(magnet => magnet.hash == torrent.infos.infoHash && magnet.instant));
+  }
+
+  async getProgressTorrents(torrents){
+    const res = await this.#request('GET', '/magnet/status');
+    return res.data.magnets.reduce((progress, magnet) => {
+      progress[magnet.hash] = {
+        percent: magnet.processingPerc || 0,
+        speed: magnet.downloadSpeed || 0
+      }
+      return progress;
+    }, {});
+  }
+
+  async getFilesFromHash(infoHash){
+    return this.getFilesFromMagnet(infoHash, infoHash);
+  }
+
+  async getFilesFromMagnet(url, infoHash){
+    const body = new FormData();
+    body.append('magnets[]', url);
+    const res = await this.#request('POST', `/magnet/upload`, {body});
+    const magnet = res.data.magnets[0] || res.data.magnets;
+    return this.#getFilesFromTorrent(magnet.id);
+  }
+
+  async getFilesFromBuffer(buffer, infoHash){
+    const body = new FormData();
+    body.append('files[0]', new Blob([buffer]), 'file.torrent');
+    const res = await this.#request('POST', `/magnet/upload/file`, {body});
+    const file = res.data.files[0] || res.data.files;
+    return this.#getFilesFromTorrent(file.id);
+  }
+
+  async getDownload(file){
+    const query = {link: file.url};
+    const res = await this.#request('GET', '/link/unlock', {query});
+    return res.data.link;
+  }
+
+  async getUserHash(){
+    return createHash('md5').update(this.#apiKey).digest('hex');
+  }
+
+  async #getFilesFromTorrent(id){
+
+    const query = {id};
+    let torrent = (await this.#request('GET', '/magnet/status', {query})).data.magnets;
+
+    if(torrent.status != 'Ready'){
+      throw new Error(ERROR.NOT_READY);
+    }
+
+    return torrent.links.map((file, index) => {
+      return {
+        name: file.filename,
+        size: file.size,
+        id: `${torrent.id}:${index}`,
+        url: file.link,
+        ready: true
+      };
+    });
+
+  }
+
+  async #request(method, path, opts){
+
+    opts = opts || {};
+    opts = Object.assign(opts, {
+      method,
+      headers: Object.assign({
+        'user-agent': 'jackettio',
+        'accept': 'application/json',
+        'authorization': `Bearer ${this.#apiKey}`
+      }, opts.headers || {}),
+      query: Object.assign({
+        'agent': 'jackettio',
+        'ip': this.#ip
+      }, opts.query || {})
+    });
+
+    const url = `https://api.alldebrid.com/v4${path}?${new URLSearchParams(opts.query).toString()}`;
+    const res = await fetch(url, opts);
+    const data = await res.json();
+
+    if(data.status != 'success'){
+      console.log(data);
+      switch(data.error.code || ''){
+        case 'AUTH_BAD_APIKEY':
+        case 'AUTH_MISSING_APIKEY':
+          throw new Error(ERROR.EXPIRED_API_KEY);
+        case 'AUTH_BLOCKED':
+          throw new Error(ERROR.TWO_FACTOR_AUTH);
+        case 'MAGNET_MUST_BE_PREMIUM':
+        case 'FREE_TRIAL_LIMIT_REACHED':
+        case 'MUST_BE_PREMIUM':
+          throw new Error(ERROR.NOT_PREMIUM);
+        default:
+          throw new Error(`Invalid AD api result: ${JSON.stringify(data)}`);
+      }
+    }
+
+    return data;
+
+  }
+
+}

src/lib/debrid/const.js

@@ -0,0 +1,7 @@
+export const ERROR = {
+  NOT_READY: 'File not ready on debrid',
+  NOT_PREMIUM: 'You must be premium on debrid',
+  EXPIRED_API_KEY: 'Api key expired',
+  ACCESS_DENIED: 'Access denied',
+  TWO_FACTOR_AUTH: 'Two-Factor authentication needed'
+};

src/lib/debrid/debridlink.js

@@ -0,0 +1,144 @@
+import {createHash} from 'crypto';
+import {ERROR} from './const.js';
+import {wait} from '../util.js';
+
+export default class DebridLink {
+
+  static id = 'debridlink';
+  static name = 'Debrid-Link';
+  static shortName = 'DL';
+  static configFields = [
+    {
+      type: 'text', 
+      name: 'debridApiKey', 
+      label: `Debrid-Link API Key`, 
+      required: true, 
+      href: {value: 'https://debrid-link.com/webapp/apikey', label:'Get API Key Here'}
+    }
+  ];
+
+  #apiKey;
+  #ip;
+
+  constructor(userConfig) {
+    Object.assign(this, this.constructor);
+    this.#apiKey = userConfig.debridApiKey;
+    this.#ip = userConfig.ip || '';
+  }
+
+  async getTorrentsCached(torrents){
+    const hashList = torrents.map(torrent => torrent.infos.infoHash).filter(Boolean);
+    const query = {url: hashList.join(',')};
+    const res = await this.#request('GET', '/seedbox/cached', {query});
+    return torrents.filter(torrent => res.value[torrent.infos.infoHash]);
+  }
+
+  async getProgressTorrents(torrents){
+    const res = await this.#request('GET', '/seedbox/list');
+    return res.value.reduce((progress, torrent) => {
+      progress[torrent.hashString] = {
+        percent: torrent.downloadPercent || 0,
+        speed: torrent.downloadSpeed || 0
+      }
+      return progress;
+    }, {});
+  }
+
+  async getFilesFromHash(infoHash){
+    return this.getFilesFromMagnet(infoHash, infoHash);
+  }
+
+  async getFilesFromMagnet(url, infoHash){
+    const body = {url, async: true};
+    const res = await this.#request('POST', `/seedbox/add`, {body});
+    return this.#getFilesFromTorrent(res.value);
+  }
+
+  async getFilesFromBuffer(buffer, infoHash){
+    const body = new FormData();
+    body.append('file', new Blob([buffer]), 'file.torrent');
+    const res = await this.#request('POST', `/seedbox/add`, {body});
+    return this.#getFilesFromTorrent(res.value);
+  }
+
+  async getDownload(file){
+
+    if(!file.ready){
+      throw new Error(ERROR.NOT_READY);
+    }
+
+    return file.url;
+
+  }
+
+  async getUserHash(){
+    return createHash('md5').update(this.#apiKey).digest('hex');
+  }
+
+  async #getFilesFromTorrent(torrent){
+
+    if(!torrent.files.length){
+      throw new Error(ERROR.NOT_READY);
+    }
+
+    return torrent.files.map((file, index) => {
+      return {
+        name: file.name,
+        size: file.size,
+        id: `${torrent.id}:${index}`,
+        url: file.downloadUrl,
+        ready: file.downloadPercent === 100
+      };
+    });
+
+  }
+
+  async #request(method, path, opts){
+
+    opts = opts || {};
+    opts = Object.assign(opts, {
+      method,
+      headers: Object.assign(opts.headers || {}, {
+        'user-agent': 'Stremio',
+        'accept': 'application/json',
+        'authorization': `Bearer ${this.#apiKey}`
+      }),
+      query: Object.assign({ip: this.#ip}, opts.query || {})
+    });
+
+    if(method == 'POST'){
+      if(opts.body instanceof FormData){
+        opts.body.append('ip', this.#ip);
+      }else{
+        opts.body = JSON.stringify(Object.assign({ip: this.#ip}, opts.body || {}));
+        opts.headers['content-type'] = 'application/json';
+      }
+    }
+
+    const url = `https://debrid-link.com/api/v2${path}?${new URLSearchParams(opts.query).toString()}`;
+    const res = await fetch(url, opts);
+    const data = await res.json();
+
+    if(!data.success){
+      console.log(data);
+      switch(data.error || ''){
+        case 'badToken':
+          throw new Error(ERROR.EXPIRED_API_KEY);
+        case 'maxLink':
+        case 'maxLinkHost':
+        case 'maxData':
+        case 'maxDataHost':
+        case 'maxTorrent':
+        case 'torrentTooBig':
+        case 'freeServerOverload':
+          throw new Error(ERROR.NOT_PREMIUM);
+        default:
+          throw new Error(`Invalid DL api result: ${JSON.stringify(data)}`);
+      }
+    }
+
+    return data;
+
+  }
+
+}

src/lib/debrid/premiumize.js

@@ -0,0 +1,135 @@
+import {createHash} from 'crypto';
+import {ERROR} from './const.js';
+
+export default class Premiumize {
+  static id = 'premiumize';
+  static name = 'Premiumize';
+  static shortName = 'PM';
+  static configFields = [
+    {
+      type: 'text',
+      name: 'debridApiKey',
+      label: `Premiumize API Key`,
+      required: true,
+      href: { value: 'https://www.premiumize.me/account', label: 'Get API Key Here' }
+    }
+  ];
+
+  #apiKey;
+  #ip;
+  #apiUrl = 'https://www.premiumize.me/api';
+
+  constructor(userConfig) {
+    Object.assign(this, this.constructor);
+    this.#apiKey = userConfig.debridApiKey;
+    this.#ip = userConfig.ip || '';
+  }
+
+  async getTorrentsCached(torrents, isValidCachedFiles) {
+    const hashList = torrents.map(torrent => torrent.infos.infoHash);
+    const params = new URLSearchParams({ apikey: this.#apiKey });
+    hashList.forEach(hash => params.append('items[]', hash));
+    
+    const res = await this.#request('GET', '/cache/check', { query: params });
+    return torrents.filter((torrent, index) => res.response[index]);
+  }
+
+  // Required by jackettio.js for progress tracking
+  async getProgressTorrents(torrents) {
+    const res = await this.#request('GET', '/transfer/list');
+    return res.transfers.reduce((progress, transfer) => {
+      progress[transfer.hash] = {
+        percent: transfer.progress * 100 || 0,
+        speed: transfer.speed || 0
+      };
+      return progress;
+    }, {});
+  }
+
+  async getFilesFromHash(infoHash) {
+    return this.getFilesFromMagnet(`magnet:?xt=urn:btih:${infoHash}`, infoHash);
+  }
+
+  async getFilesFromMagnet(magnet, infoHash) {
+    const body = new FormData();
+    body.append('apikey', this.#apiKey);
+    body.append('src', magnet);
+
+    const res = await this.#request('POST', '/transfer/directdl', { body });
+    
+    return res.content.map((file, index) => ({
+      name: file.path.split('/').pop(),
+      size: file.size,
+      id: `${infoHash}:${index}`,
+      url: file.link,
+      ready: true
+    }));
+  }
+
+  async getFilesFromBuffer(buffer, infoHash) {
+    const body = new FormData();
+    body.append('apikey', this.#apiKey);
+    body.append('src', new Blob([buffer]), 'file.torrent');
+
+    try {
+      const res = await this.#request('POST', '/transfer/directdl', { body });
+      
+      return res.content.map((file, index) => ({
+        name: file.path.split('/').pop(),
+        size: file.size,
+        id: `${infoHash}:${index}`,
+        url: file.link,
+        ready: true
+      }));
+    } catch(err) {
+      // If torrent upload fails, fall back to magnet
+      if(err.message === 'Src not compatible.') {
+        return this.getFilesFromHash(infoHash);
+      }
+      throw err;
+    }
+  }
+
+  async getDownload(file) {
+    if (!file.ready) {
+      throw new Error(ERROR.NOT_READY);
+    }
+    return file.url;
+  }
+
+  async getUserHash() {
+    return createHash('md5').update(this.#apiKey).digest('hex');
+  }
+
+  async #request(method, path, opts = {}) {
+    opts = Object.assign(opts, {
+      method,
+      headers: Object.assign({
+        'accept': 'application/json'
+      }, opts.headers || {}),
+      query: opts.query || new URLSearchParams({ apikey: this.#apiKey })
+    });
+
+    if (method === 'POST' && opts.body instanceof FormData) {
+      // FormData handles Content-Type header automatically
+      if (this.#ip) opts.body.append('ip', this.#ip);
+    }
+
+    const url = `${this.#apiUrl}${path}?${opts.query.toString()}`;
+    const res = await fetch(url, opts);
+    const data = await res.json();
+
+    if (!data || data.status !== "success") {
+      switch(data.message) {
+        case 'Invalid API key.':
+          throw new Error(ERROR.EXPIRED_API_KEY);
+        case 'Premium accounts only.':
+          throw new Error(ERROR.NOT_PREMIUM);
+        default:
+          throw new Error(data.message || 'Unknown Premiumize API error');
+      }
+    }
+
+    return data;
+  }
+}

src/lib/debrid/realdebrid.js

@@ -0,0 +1,203 @@
+import {createHash} from 'crypto';
+import {ERROR} from './const.js';
+import {wait, isVideo} from '../util.js';
+
+export default class RealDebrid {
+
+  static id = 'realdebrid';
+  static name = 'Real-Debrid';
+  static shortName = 'RD';
+  static configFields = [
+    {
+      type: 'text', 
+      name: 'debridApiKey', 
+      label: `Real-Debrid API Key`, 
+      required: true, 
+      href: {value: 'https://real-debrid.com/apitoken', label:'Get API Key Here'}
+    }
+  ];
+
+  #apiKey;
+  #ip;
+
+  constructor(userConfig) {
+    Object.assign(this, this.constructor);
+    this.#apiKey = userConfig.debridApiKey;
+    this.#ip = userConfig.ip || '';
+  }
+
+  async getTorrentsCached(torrents, isValidCachedFiles){
+    const hashList = torrents.map(torrent => torrent.infos.infoHash).filter(Boolean);
+    const res = await this.#request('GET', `/torrents/instantAvailability/${hashList.join('/')}`);
+    return torrents.filter(torrent => {
+      const cachedFiles = [];
+      const caches = (res[torrent.infos.infoHash]?.rd || []).filter(this.#isVideoCache);
+      for(const cache of caches){
+        for(const file of Object.values(cache)){
+          const f = {name: file.filename, size: file.filesize};
+          if(!cachedFiles.includes(f))cachedFiles.push(f);
+        }
+      }
+      return cachedFiles.length > 0 && isValidCachedFiles(cachedFiles);
+    });
+  }
+
+  async getProgressTorrents(torrents){
+    const res = await this.#request('GET', '/torrents');
+    return res.reduce((progress, torrent) => {
+      progress[torrent.hash] = {
+        percent: torrent.progress || 0,
+        speed: torrent.speed || 0
+      }
+      return progress;
+    }, {});
+  }
+
+  async getFilesFromHash(infoHash){
+    return this.getFilesFromMagnet(`magnet:?xt=urn:btih:${infoHash}`, infoHash);
+  }
+
+  async getFilesFromMagnet(magnet, infoHash){
+    const torrentId = await this.#searchTorrentIdByHash(infoHash);
+    if(torrentId)return this.#getFilesFromTorrent(torrentId);
+    const body = new FormData();
+    body.append('magnet', magnet);
+    const res = await this.#request('POST', `/torrents/addMagnet`, {body});
+    return this.#getFilesFromTorrent(res.id);
+  }
+
+  async getFilesFromBuffer(buffer, infoHash){
+    const torrentId = await this.#searchTorrentIdByHash(infoHash);
+    if(torrentId)return this.#getFilesFromTorrent(torrentId);
+    const body = buffer;
+    const res = await this.#request('PUT', `/torrents/addTorrent`, {body});
+    return this.#getFilesFromTorrent(res.id);
+  }
+
+  async getDownload(file){
+
+    const [torrentId, fileId] = file.id.split(':');
+
+    let torrent = await this.#request('GET', `/torrents/info/${torrentId}`);
+    let body;
+
+    if(torrent.status == 'waiting_files_selection'){
+
+      const caches = await this.#request('GET', `/torrents/instantAvailability/${torrent.hash}`);
+      const bestCache = (caches[torrent.hash]?.rd || [])
+        .filter(cache => cache[fileId] && this.#isVideoCache(cache))
+        .sort((a, b) => Object.values(b).length - Object.values(a).length)
+        .shift();
+
+      const fileIds = bestCache ? Object.keys(bestCache) : torrent.files.filter(file => isVideo(file.path)).map(file => file.id);
+      body = new FormData();
+      body.append('files', fileIds.join(','));
+
+      await this.#request('POST', `/torrents/selectFiles/${torrentId}`, {body});
+      torrent = await this.#request('GET', `/torrents/info/${torrentId}`);
+
+    }
+
+    if(torrent.status != 'downloaded'){
+      throw new Error(ERROR.NOT_READY);
+    }
+
+    const linkIndex = torrent.files.filter(file => file.selected).findIndex(file => file.id == fileId);
+    const link = torrent.links[linkIndex] || false;
+
+    if(!link){
+      throw new Error(`LinkIndex or link not found`);
+    }
+
+    body = new FormData();
+    body.append('link', link);
+    const res = await this.#request('POST', '/unrestrict/link', {body});
+    return res.download;
+
+  }
+
+  async getUserHash(){
+    return createHash('md5').update(this.#apiKey).digest('hex');
+  }
+
+  // Return false when a non video file is available in the cache to avoid rar files
+  #isVideoCache(cache){
+    return !Object.values(cache).find(file => !isVideo(file.filename));
+  }
+
+  async #getFilesFromTorrent(id){
+
+    let torrent = await this.#request('GET', `/torrents/info/${id}`);
+
+    return torrent.files.map((file, index) => {
+      return {
+        name: file.path.split('/').pop(),
+        size: file.bytes,
+        id: `${torrent.id}:${file.id}`,
+        url: '',
+        ready: null
+      };
+    });
+
+  }
+
+  async #searchTorrentIdByHash(hash){
+
+    const torrents = await this.#request('GET', `/torrents`);
+
+    for(let torrent of torrents){
+      if(torrent.hash == hash && ['magnet_conversion', 'waiting_files_selection', 'queued', 'downloading', 'downloaded'].includes(torrent.status)){
+        return torrent.id;
+      }
+    }
+
+  }
+
+  async #request(method, path, opts){
+
+    opts = opts || {};
+    opts = Object.assign(opts, {
+      method,
+      headers: Object.assign(opts.headers || {}, {
+        'accept': 'application/json',
+        'authorization': `Bearer ${this.#apiKey}`
+      }),
+      query: opts.query || {}
+    });
+
+    if(method == 'POST' || method == 'PUT'){
+      opts.body = opts.body || new FormData();
+      if(this.#ip && opts.body instanceof FormData)opts.body.append('ip', this.#ip);
+    }
+
+    const url = `https://api.real-debrid.com/rest/1.0${path}?${new URLSearchParams(opts.query).toString()}`;
+    const res = await fetch(url, opts);
+    let data;
+
+    try {
+      data = await res.json();
+    }catch(err){
+      data = res.status >= 400 ? {error_code: -2, error: `Empty response ${res.status}`} : {};
+    }
+
+    if(data.error_code){
+      switch(data.error_code){
+        case 8:
+          throw new Error(ERROR.EXPIRED_API_KEY);
+        case 9:
+          throw new Error(ERROR.ACCESS_DENIED);
+        case 10:
+        case 11:
+          throw new Error(ERROR.TWO_FACTOR_AUTH);
+        case 20:
+          throw new Error(ERROR.NOT_PREMIUM);
+        default:
+          throw new Error(`Invalid RD api result: ${JSON.stringify(data)}`);
+      }
+    }
+
+    return data;
+
+  }
+
+}

src/lib/icon.js

@@ -0,0 +1,34 @@
+import { writeFile, readFile } from 'node:fs/promises';
+import path from 'path';
+import config from './config.js';
+
+let ICON_LOCATION = path.join(import.meta.dirname, '../static/img/icon.png');
+
+export async function download(){
+  const res = await fetch(config.addonIcon, {method: 'GET'});
+  if(!res.ok){
+    throw new Error('Network response was not ok');
+  }
+  let extension = null;
+  if(res.headers.has('content-type')){
+    const matches = res.headers.get('content-type').match(/image\/([a-z0-9]+)/i);
+    if(matches && matches.length > 1)extension = matches[1];
+  }
+  if(!extension && res.headers.has('content-disposition')){
+    const matches = res.headers.get('content-disposition').match(/filename\*?=['"]?(?:UTF-\d['"]*)?([^;\r\n"']*)['"]?;?/i);
+    if(matches && matches.length > 1)extension = matches[1].split('.').pop();
+  }
+  if(!extension){
+    throw new Error(`No valid image found: ${res.headers.get('content-type')} / ${res.headers.get('content-disposition')}`);
+  }
+  const location = `${config.dataFolder}/icon.${extension}`;
+  const buffer = await res.arrayBuffer();
+  await writeFile(location, new Uint8Array(buffer));
+  console.log(`Icon downloaded: ${location}`);
+  ICON_LOCATION = location;
+  return location;
+}
+
+export async function getLocation(){
+  return ICON_LOCATION;
+}

src/lib/jackett.js

@@ -0,0 +1,194 @@
+import crypto from 'crypto';
+import {Parser} from "xml2js";
+import config from './config.js';
+import cache from './cache.js';
+import {numberPad, parseWords} from './util.js';
+
+export const CATEGORY = {
+  MOVIE: [2000,5000],
+  SERIES: 5000
+};
+
+export async function searchMovieTorrents({indexer, name, year}){
+
+  indexer = indexer || 'all';
+  const cacheKey = `jackettItems:2:movie:${indexer}:${name}:${year}`;
+  let items = await cache.get(cacheKey);
+
+  if(!items){
+    const res = await jackettApi(
+      `/api/v2.0/indexers/${indexer}/results/torznab/api`,
+      // year is buggy with some indexers
+      {t: 'search', cat: CATEGORY.MOVIE, q: name /*, year: year*/}
+    );
+    items = res?.rss?.channel?.item || [];
+    cache.set(cacheKey, items, {ttl: items.length > 0 ? 3600*36 : 60});
+  }
+
+  return normalizeItems(items);
+
+}
+
+export async function searchSerieTorrents({indexer, name, year}){
+
+  indexer = indexer || 'all';
+  const cacheKey = `jackettItems:2:serie:${indexer}:${name}:${year}`;
+  let items = await cache.get(cacheKey);
+
+  if(!items){
+    const res = await jackettApi(
+      `/api/v2.0/indexers/${indexer}/results/torznab/api`,
+      {t: 'search', cat: CATEGORY.SERIES, q: `${name}`}
+    );
+    items = res?.rss?.channel?.item || [];
+    cache.set(cacheKey, items, {ttl: items.length > 0 ? 3600*36 : 60});
+  }
+
+  return normalizeItems(items);
+
+}
+
+export async function searchSeasonTorrents({indexer, name, year, season}){
+
+  indexer = indexer || 'all';
+  const cacheKey = `jackettItems:2:season:${indexer}:${name}:${year}:${season}`;
+  let items = await cache.get(cacheKey);
+
+  if(!items){
+    const res = await jackettApi(
+      `/api/v2.0/indexers/${indexer}/results/torznab/api`,
+      {t: 'search', cat: CATEGORY.SERIES, q: `${name} S${numberPad(season)}`}
+    );
+    items = res?.rss?.channel?.item || [];
+    cache.set(cacheKey, items, {ttl: items.length > 0 ? 3600*36 : 60});
+  }
+
+  return normalizeItems(items);
+
+}
+
+export async function searchEpisodeTorrents({indexer, name, year, season, episode}){
+
+  indexer = indexer || 'all';
+  const cacheKey = `jackettItems:2:episode:${indexer}:${name}:${year}:${season}:${episode}`;
+  let items = await cache.get(cacheKey);
+
+  if(!items){
+    const res = await jackettApi(
+      `/api/v2.0/indexers/${indexer}/results/torznab/api`,
+      {t: 'search', cat: CATEGORY.SERIES, q: `${name} S${numberPad(season)}E${numberPad(episode)}`}
+    );
+    items = res?.rss?.channel?.item || [];
+    cache.set(cacheKey, items, {ttl: items.length > 0 ? 3600*36 : 60});
+  }
+
+  return normalizeItems(items);
+
+}
+
+export async function getIndexers(){
+
+  const res = await jackettApi(
+    '/api/v2.0/indexers/all/results/torznab/api',
+    {t: 'indexers', configured: 'true'}
+  );
+
+  return normalizeIndexers(res?.indexers?.indexer || []);
+
+}
+
+async function jackettApi(path, query){
+
+  const params = new URLSearchParams(query || {});
+  params.set('apikey', config.jackettApiKey);
+
+  const url = `${config.jackettUrl}${path}?${params.toString()}`;
+
+  let data;
+  const res = await fetch(url);
+  if(res.headers.get('content-type').includes('application/json')){
+    data = await res.json();
+  }else{
+    const text = await res.text();
+    const parser = new Parser({explicitArray: false, ignoreAttrs: false});
+    data = await parser.parseStringPromise(text);
+  }
+
+  if(data.error){
+    throw new Error(`jackettApi: ${url.replace(/apikey=[a-z0-9\-]+/, 'apikey=****')} : ${data.error?.$?.description || data.error}`);
+  }
+
+  return data;
+
+}
+
+function normalizeItems(items){
+  return forceArray(items).map(item => {
+    item = mergeDollarKeys(item);
+    const attr = item['torznab:attr'].reduce((obj, item) => {
+      obj[item.name] = item.value;
+      return obj;
+    }, {});
+    const quality = item.title.match(/(2160|1080|720|480|360)p/);
+    const title = parseWords(item.title).join(' ');
+    const year = item.title.replace(quality ? quality[1] : '', '').match(/(19|20[\d]{2})/);
+    return {
+      name: item.title,
+      guid: item.guid,
+      indexerId: item.jackettindexer.id,
+      id: crypto.createHash('sha1').update(item.guid).digest('hex'),
+      size: parseInt(item.size),
+      link: item.link,
+      seeders: parseInt(attr.seeders || 0),
+      peers: parseInt(attr.peers || 0),
+      infoHash: attr.infohash || '',
+      magneturl: attr.magneturl || '', 
+      type: item.type,
+      quality: quality ? parseInt(quality[1]) : 0,
+      year: year ? parseInt(year.pop()) : 0,
+      languages: config.languages.filter(lang => title.match(lang.pattern))
+    };
+  });
+}
+
+function normalizeIndexers(items){
+  return forceArray(items).map(item => {
+    item = mergeDollarKeys(item);
+    const searching = item.caps.searching;
+    return {
+      id: item.id,
+      configured: item.configured == 'true',
+      title: item.title,
+      language: item.language,
+      type: item.type,
+      categories: forceArray(item.caps.categories.category).map(category => parseInt(category.id)),
+      searching: {
+        movie: {
+          available: searching['movie-search'].available == 'yes', 
+          supportedParams: searching['movie-search'].supportedParams.split(',')
+        },
+        series: {
+          available: searching['tv-search'].available == 'yes', 
+          supportedParams: searching['tv-search'].supportedParams.split(',')
+        }
+      }
+    };
+  });
+}
+
+function mergeDollarKeys(item){
+  if(item.$){
+    item = {...item.$, ...item};
+    delete item.$;
+  }
+  for(let key in item){
+    if(typeof(item[key]) === 'object'){
+      item[key] = mergeDollarKeys(item[key]);
+    }
+  }
+  return item;
+}
+
+function forceArray(value){
+  return Array.isArray(value) ? value : [value];
+}

src/lib/jackettio.js

@@ -0,0 +1,439 @@
+import pLimit from 'p-limit';
+import {parseWords, numberPad, sortBy, bytesToSize, wait, promiseTimeout} from './util.js';
+import config from './config.js';
+import cache from './cache.js';
+import { updateUserConfigWithMediaFlowIp, applyMediaflowProxyIfNeeded } from './mediaflowProxy.js';
+import * as meta from './meta.js';
+import * as jackett from './jackett.js';
+import * as debrid from './debrid.js';
+import * as torrentInfos from './torrentInfos.js';
+
+const slowIndexers = {};
+
+const actionInProgress = {
+  getTorrents: {},
+  getDownload: {}
+};
+
+function parseStremioId(stremioId){
+  const [id, season, episode] = stremioId.split(':');
+  return {id, season: parseInt(season || 0), episode: parseInt(episode || 0)};
+}
+
+async function getMetaInfos(type, stremioId, language){
+  const {id, season, episode} = parseStremioId(stremioId);
+  if(type == 'movie'){
+    return meta.getMovieById(id, language);
+  }else if(type == 'series'){
+    return meta.getEpisodeById(id, season, episode, language);
+  }else{
+    throw new Error(`Unsuported type ${type}`);
+  }
+}
+
+async function mergeDefaultUserConfig(userConfig){
+  config.immulatableUserConfigKeys.forEach(key => delete userConfig[key]);
+  userConfig = Object.assign({}, config.defaultUserConfig, userConfig);
+  userConfig = await updateUserConfigWithMediaFlowIp(userConfig);
+  return userConfig;
+}
+
+function priotizeItems(allItems, priotizeItems, max){
+  max = max || 0;
+  if(typeof(priotizeItems) == 'function'){
+    priotizeItems = allItems.filter(priotizeItems);
+    if(max > 0)priotizeItems.splice(max);
+  }
+  if(priotizeItems && priotizeItems.length){
+    allItems = allItems.filter(item => !priotizeItems.find(i => i == item));
+    allItems.unshift(...priotizeItems);
+  }
+  return allItems;
+}
+
+function searchEpisodeFile(files, season, episode){
+  return files.find(file => file.name.includes(`S${numberPad(season, 2)}E${numberPad(episode, 3)}`))
+    || files.find(file => file.name.includes(`S${numberPad(season, 2)}E${numberPad(episode, 2)}`))
+    || files.find(file => file.name.includes(`${season}${numberPad(episode, 2)}`))
+    || files.find(file => file.name.includes(`${numberPad(episode, 2)}`))
+    || false;
+}
+
+function getSlowIndexerStats(indexerId){
+  slowIndexers[indexerId] = (slowIndexers[indexerId] || []).filter(item => new Date() - item.date < config.slowIndexerWindow);
+  return {
+    min: Math.min(...slowIndexers[indexerId].map(item => item.duration)),
+    avg: Math.round(slowIndexers[indexerId].reduce((acc, item) => acc + item.duration, 0) / slowIndexers[indexerId].length),
+    max: Math.max(...slowIndexers[indexerId].map(item => item.duration)),
+    count: slowIndexers[indexerId].length
+  }
+}
+
+async function timeoutIndexerSearch(indexerId, promise, timeout){
+  const start = new Date();
+  const res = await promiseTimeout(promise, timeout).catch(err => []);
+  const duration = new Date() - start;
+  if(timeout > config.slowIndexerDuration){
+    if(duration > config.slowIndexerDuration){
+      console.log(`Slow indexer detected : ${indexerId} : ${duration}ms`);
+      slowIndexers[indexerId].push({duration, date: new Date()});
+    }else{
+      slowIndexers[indexerId] = [];
+    }
+  }
+  return res;
+}
+
+async function getTorrents(userConfig, metaInfos, debridInstance){
+
+  while(actionInProgress.getTorrents[metaInfos.stremioId]){
+    await wait(500);
+  }
+  actionInProgress.getTorrents[metaInfos.stremioId] = true;
+
+  try {
+
+    const {qualities, excludeKeywords, maxTorrents, sortCached, sortUncached, priotizePackTorrents, priotizeLanguages, indexerTimeoutSec} = userConfig;
+    const {id, season, episode, type, stremioId, year} = metaInfos;
+
+    let torrents = [];
+    let startDate = new Date();
+
+    console.log(`${stremioId} : Searching torrents ...`);
+
+    const sortSearch = [['seeders', true]];
+    const filterSearch = (torrent) => {
+      if(!qualities.includes(torrent.quality))return false;
+      const torrentWords = parseWords(torrent.name.toLowerCase());
+      if(excludeKeywords.find(word => torrentWords.includes(word)))return false;
+      return true;
+    };
+    const filterLanguage = (torrent) => {
+      if(priotizeLanguages.length == 0)return true;
+      return torrent.languages.find(lang => ['multi'].concat(priotizeLanguages).includes(lang.value));
+    };
+    const filterYear = (torrent) => !torrent.year || torrent.year == year;
+    const filterSlowIndexer = (indexer) => config.slowIndexerRequest <= 0 || getSlowIndexerStats(indexer.id).count < config.slowIndexerRequest;
+
+    let indexers = (await jackett.getIndexers());
+    let availableIndexers = indexers.filter(indexer => indexer.searching[type].available);
+    let availableFastIndexers = availableIndexers.filter(filterSlowIndexer);
+    if(availableFastIndexers.length)availableIndexers = availableFastIndexers;
+    let userIndexers = availableIndexers.filter(indexer => (userConfig.indexers.includes(indexer.id) || userConfig.indexers.includes('all')));
+
+    if(userIndexers.length){
+      indexers = userIndexers;
+    }else if(availableIndexers.length){
+      console.log(`${stremioId} : User defined indexers "${userConfig.indexers.join(', ')}" not available, fallback to all "${type}" indexers`);
+      indexers = availableIndexers;
+    }else if(indexers.length){
+      console.log(`${stremioId} : User defined indexers "${userConfig.indexers.join(', ')}" or "${type}" indexers not available, fallback to all indexers`);
+    }else{
+      throw new Error(`${stremioId} : No indexer configured in jackett`);
+    }
+
+    console.log(`${stremioId} : ${indexers.length} indexers selected : ${indexers.map(indexer => indexer.title).join(', ')}`);
+
+    if(type == 'movie'){
+
+      const promises = indexers.map(indexer => timeoutIndexerSearch(indexer.id, jackett.searchMovieTorrents({...metaInfos, indexer: indexer.id}), indexerTimeoutSec*1000));
+      torrents = [].concat(...(await Promise.all(promises)));
+
+      console.log(`${stremioId} : ${torrents.length} torrents found in ${(new Date() - startDate) / 1000}s`);
+
+      const yearTorrents = torrents.filter(filterYear);
+      if(yearTorrents.length)torrents = yearTorrents;
+      torrents = torrents.filter(filterSearch).sort(sortBy(...sortSearch));
+      torrents = priotizeItems(torrents, filterLanguage, Math.max(1, Math.round(maxTorrents * 0.33)));
+      torrents = torrents.slice(0, maxTorrents + 2);
+
+    }else if(type == 'series'){
+
+      const episodesPromises = indexers.map(indexer => timeoutIndexerSearch(indexer.id, jackett.searchEpisodeTorrents({...metaInfos, indexer: indexer.id}), indexerTimeoutSec*1000));
+      // const packsPromises = indexers.map(indexer => promiseTimeout(jackett.searchSeasonTorrents({...metaInfos, indexer: indexer.id}), indexerTimeoutSec*1000).catch(err => []));
+      const packsPromises = indexers.map(indexer => timeoutIndexerSearch(indexer.id, jackett.searchSerieTorrents({...metaInfos, indexer: indexer.id}), indexerTimeoutSec*1000));
+
+      const episodesTorrents = [].concat(...(await Promise.all(episodesPromises))).filter(filterSearch);
+      // const packsTorrents = [].concat(...(await Promise.all(packsPromises))).filter(torrent => filterSearch(torrent) && parseWords(torrent.name.toUpperCase()).includes(`S${numberPad(season)}`));
+      const packsTorrents = [].concat(...(await Promise.all(packsPromises))).filter(torrent => {
+        if(!filterSearch(torrent))return false;
+        const words = parseWords(torrent.name.toLowerCase());
+        const wordsStr = words.join(' ');
+        if(
+          // Season x
+          wordsStr.includes(`season ${season}`)
+          // SXX
+          || words.includes(`s${numberPad(season)}`)
+        ){
+          return true;
+        }
+        // From SXX to SXX
+        const range = wordsStr.match(/s([\d]{2,}) s([\d]{2,})/);
+        if(range && season >= parseInt(range[1]) && season <= parseInt(range[2])){
+          return true;
+        }
+        // Complete without season number (serie pack)
+        if(words.includes('complete') && !wordsStr.match(/ (s[\d]{2,}|season [\d]) /)){
+          return true;
+        }
+        return false;
+      });
+
+      torrents = [].concat(episodesTorrents, packsTorrents);
+
+      console.log(`${stremioId} : ${torrents.length} torrents found in ${(new Date() - startDate) / 1000}s`);
+
+      const yearTorrents = torrents.filter(filterYear);
+      if(yearTorrents.length)torrents = yearTorrents;
+      torrents = torrents.filter(filterSearch).sort(sortBy(...sortSearch));
+      torrents = priotizeItems(torrents, filterLanguage, Math.max(1, Math.round(maxTorrents * 0.33)));
+      torrents = torrents.slice(0, maxTorrents + 2);
+
+      if(priotizePackTorrents > 0 && packsTorrents.length && !torrents.find(t => packsTorrents.includes(t))){
+        const bestPackTorrents = packsTorrents.slice(0, Math.min(packsTorrents.length, priotizePackTorrents));
+        torrents.splice(bestPackTorrents.length * -1, bestPackTorrents.length, ...bestPackTorrents);
+      }
+
+    }
+
+    console.log(`${stremioId} : ${torrents.length} torrents filtered, get torrents infos ...`);
+    startDate = new Date();
+
+    const limit = pLimit(5);
+    torrents = await Promise.all(torrents.map(torrent => limit(async () => {
+      try {
+        torrent.infos = await promiseTimeout(torrentInfos.get(torrent), Math.min(30, indexerTimeoutSec)*1000);
+        return torrent;
+      }catch(err){
+        console.log(`${stremioId} Failed getting torrent infos for ${torrent.id} from indexer ${torrent.indexerId}`);
+        console.log(`${stremioId} ${torrent.link.replace(/apikey=[a-z0-9\-]+/, 'apikey=****')}`, err);
+        return false;
+      }
+    })));
+    torrents = torrents.filter(torrent => torrent && torrent.infos)
+      .filter((torrent, index, items) => items.findIndex(t => t.infos.infoHash == torrent.infos.infoHash) === index)
+      .slice(0, maxTorrents);
+
+    console.log(`${stremioId} : ${torrents.length} torrents infos found in ${(new Date() - startDate) / 1000}s`);
+
+    if(torrents.length == 0){
+      throw new Error(`No torrent infos for type ${type} and id ${stremioId}`);
+    }
+
+    if(debridInstance){
+
+      try {
+
+        const isValidCachedFiles = type == 'series' ? files => !!searchEpisodeFile(files, season, episode) : files => true;
+        const cachedTorrents = (await debridInstance.getTorrentsCached(torrents, isValidCachedFiles)).map(torrent => {
+          torrent.isCached = true;
+          return torrent;
+        });
+        const uncachedTorrents = torrents.filter(torrent => cachedTorrents.indexOf(torrent) === -1);
+
+        if(config.replacePasskey && !(userConfig.passkey && userConfig.passkey.match(new RegExp(config.replacePasskeyPattern)))){
+          uncachedTorrents.forEach(torrent => {
+            if(torrent.infos.private){
+              torrent.disabled = true;
+              torrent.infoText = 'Uncached torrent require a passkey configuration';
+            }
+          });
+        }
+
+        console.log(`${stremioId} : ${cachedTorrents.length} cached torrents on ${debridInstance.shortName}`);
+
+        torrents = priotizeItems(cachedTorrents.sort(sortBy(...sortCached)), filterLanguage);
+
+        if(!userConfig.hideUncached){
+          torrents.push(...priotizeItems(uncachedTorrents.sort(sortBy(...sortUncached)), filterLanguage));
+        }
+      
+        const progress = await debridInstance.getProgressTorrents(torrents);
+        torrents.forEach(torrent => torrent.progress = progress[torrent.infos.infoHash] || null);
+
+      }catch(err){
+
+        console.log(`${stremioId} : ${debridInstance.shortName} : ${err.message || err}`);
+
+        if(err.message == debrid.ERROR.EXPIRED_API_KEY){
+          torrents.forEach(torrent => {
+            torrent.disabled = true;
+            torrent.infoText = 'Unable to verify cache (+): Expired Debrid API Key.';
+          });
+        }
+
+      }
+
+    }
+
+    return torrents;
+
+  }finally{
+
+    delete actionInProgress.getTorrents[metaInfos.stremioId];
+
+  }
+
+}
+
+async function prepareNextEpisode(userConfig, metaInfos, debridInstance){
+
+  try {
+
+    const {stremioId} = metaInfos;
+    const nextEpisodeIndex = metaInfos.episodes.findIndex(e => e.episode == metaInfos.episode && e.season == metaInfos.season) + 1;
+    const nextEpisode = metaInfos.episodes[nextEpisodeIndex] || false;
+
+    if(nextEpisode){
+
+      metaInfos = await meta.getEpisodeById(metaInfos.id, nextEpisode.season, nextEpisode.episode, userConfig.metaLanguage);
+      const torrents = await getTorrents(userConfig, metaInfos, debridInstance);
+
+      // Cache next episode on debrid when not cached
+      if(userConfig.forceCacheNextEpisode && torrents.length && !torrents.find(torrent => torrent.isCached)){
+        console.log(`${stremioId} : Force cache next episode (${metaInfos.episode}) on debrid`);
+        const bestTorrent = torrents.find(torrent => !torrent.disabled);
+        if(bestTorrent)await getDebridFiles(userConfig, bestTorrent.infos, debridInstance);
+      }
+
+    }
+
+  }catch(err){
+
+    if(err.message != debrid.ERROR.NOT_READY){
+      console.log('cache next episode:', err);
+    }
+
+  }
+
+}
+
+async function getDebridFiles(userConfig, infos, debridInstance){
+
+  if(infos.magnetUrl){
+
+    return debridInstance.getFilesFromMagnet(infos.magnetUrl, infos.infoHash);
+
+  }else{
+
+    let buffer = await torrentInfos.getTorrentFile(infos);
+
+    if(config.replacePasskey){
+
+      if(infos.private && !userConfig.passkey){
+        return debridInstance.getFilesFromHash(infos.infoHash);
+      }
+
+      if(!userConfig.passkey.match(new RegExp(config.replacePasskeyPattern))){
+        throw new Error(`Invalid user passkey, pattern not match: ${config.replacePasskeyPattern}`);
+      }
+
+      const from = buffer.toString('binary');
+      let to = from.replace(new RegExp(config.replacePasskey, 'g'), userConfig.passkey);
+      const diffLength = from.length - to.length;
+      const announceLength = from.match(/:announce([\d]+):/);
+      if(diffLength && announceLength && announceLength[1]){
+        to = to.replace(announceLength[0], `:announce${parseInt(announceLength[1]) - diffLength}:`);
+      }
+      buffer = Buffer.from(to, 'binary');
+
+    }
+
+    return debridInstance.getFilesFromBuffer(buffer, infos.infoHash);
+
+  }
+
+}
+
+export async function getStreams(userConfig, type, stremioId, publicUrl){
+
+  userConfig = await mergeDefaultUserConfig(userConfig);
+  const {id, season, episode} = parseStremioId(stremioId);
+  const debridInstance = debrid.instance(userConfig);
+
+  let metaInfos = await getMetaInfos(type, stremioId, userConfig.metaLanguage);
+
+  const torrents = await getTorrents(userConfig, metaInfos, debridInstance);
+
+  // Prepare next expisode torrents list
+  if(type == 'series'){
+    prepareNextEpisode({...userConfig, forceCacheNextEpisode: false}, metaInfos, debridInstance);
+  }
+
+  return torrents.map(torrent => {
+    const file = type == 'series' && torrent.infos.files.length ? searchEpisodeFile(torrent.infos.files.sort(sortBy('size', true)), season, episode) : {};
+    const quality = torrent.quality > 0 ? config.qualities.find(q => q.value == torrent.quality).label : '';
+    const rows = [torrent.name];
+    if(type == 'series' && file.name)rows.push(file.name);
+    if(torrent.infoText)rows.push(`ℹ️ ${torrent.infoText}`);
+    rows.push([`💾${bytesToSize(file.size || torrent.size)}`, `👥${torrent.seeders}`, `⚙️${torrent.indexerId}`, ...(torrent.languages || []).map(language => language.emoji)].join(' '));
+    if(torrent.progress && !torrent.isCached){
+      rows.push(`⬇️ ${torrent.progress.percent}% ${bytesToSize(torrent.progress.speed)}/s`);
+    }
+    return {
+      name: `[${debridInstance.shortName}${torrent.isCached ? '+' : ''}] ${userConfig.enableMediaFlow ? '🕵🏼‍♂️ ' : ''}${config.addonName} ${quality}`,
+      title: rows.join("\n"),
+      url: torrent.disabled ? '#' : `${publicUrl}/${btoa(JSON.stringify(userConfig))}/download/${type}/${stremioId}/${torrent.id}`
+    };
+  });
+
+}
+
+export async function getDownload(userConfig, type, stremioId, torrentId){
+
+  userConfig = await mergeDefaultUserConfig(userConfig);
+  const debridInstance = debrid.instance(userConfig);
+  const infos = await torrentInfos.getById(torrentId);
+  const {id, season, episode} = parseStremioId(stremioId);
+  const cacheKey = `download:2:${await debridInstance.getUserHash()}${userConfig.enableMediaFlow ? ':mfp': ''}:${stremioId}:${torrentId}`;
+  let files;
+  let download;
+  let waitMs = 0;
+
+  while(actionInProgress.getDownload[cacheKey]){
+    await wait(Math.min(300, waitMs+=50));
+  }
+  actionInProgress.getDownload[cacheKey] = true;
+
+  try {
+
+    // Prepare next expisode debrid cache
+    if(type == 'series' && userConfig.forceCacheNextEpisode){
+      getMetaInfos(type, stremioId, userConfig.metaLanguage).then(metaInfos => prepareNextEpisode(userConfig, metaInfos, debridInstance));
+    }
+
+    download = await cache.get(cacheKey);
+    if(download)return download;
+
+    console.log(`${stremioId} : ${debridInstance.shortName} : ${infos.infoHash} : get files ...`);
+    files = await getDebridFiles(userConfig, infos, debridInstance);
+    console.log(`${stremioId} : ${debridInstance.shortName} : ${infos.infoHash} : ${files.length} files found`);
+
+    files = files.sort(sortBy('size', true));
+
+    if(type == 'movie'){
+
+      download = await debridInstance.getDownload(files[0]);
+
+    }else if(type == 'series'){
+
+      let bestFile = searchEpisodeFile(files, season, episode) || files[0];
+      download = await debridInstance.getDownload(bestFile);
+
+    }
+
+    if(download){
+      download = applyMediaflowProxyIfNeeded(download, userConfig);
+      await cache.set(cacheKey, download, {ttl: 3600});
+      return download;
+    }
+
+    throw new Error(`No download for type ${type} and ID ${torrentId}`);
+
+  }finally{
+
+    delete actionInProgress.getDownload[cacheKey];
+
+  }
+
+}

src/lib/mediaflowProxy.js

@@ -0,0 +1,112 @@
+import crypto from 'crypto';
+import { URL } from 'url';
+import path from 'path';
+import cache from './cache.js';
+
+const PRIVATE_CIDR = /^(10\.|127\.|172\.(1[6-9]|2[0-9]|3[01])\.|192\.168\.)/;
+
+function getTextHash(text) {
+  return crypto.createHash('sha256').update(text).digest('hex');
+}
+
+async function getMediaflowProxyPublicIp(userConfig) {
+  // If the user has already provided a public IP, use it
+  if (userConfig.mediaflowPublicIp) return userConfig.mediaflowPublicIp;
+
+  const parsedUrl = new URL(userConfig.mediaflowProxyUrl);
+  if (PRIVATE_CIDR.test(parsedUrl.hostname)) {
+    // MediaFlow proxy URL is a private IP address
+    return null;
+  }
+
+  const cacheKey = `mediaflowPublicIp:${getTextHash(`${userConfig.mediaflowProxyUrl}:${userConfig.mediaflowApiPassword}`)}`;
+  try {
+    const cachedIp = await cache.get(cacheKey);
+    if (cachedIp) {
+      return cachedIp;
+    }
+
+    const response = await fetch(new URL(`/proxy/ip?api_password=${userConfig.mediaflowApiPassword}`, userConfig.mediaflowProxyUrl).toString(), {
+      method: 'GET',
+      headers: {
+      'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const data = await response.json();
+    const publicIp = data.ip;
+    if (publicIp) {
+      await cache.set(cacheKey, publicIp, { ttl: 300 }); // Cache for 5 minutes
+      return publicIp;
+    }
+  } catch (error) {
+    console.error('An error occurred:', error);
+  }
+
+  return null;
+}
+
+
+function encodeMediaflowProxyUrl(
+  mediaflowProxyUrl,
+  endpoint,
+  destinationUrl = null,
+  queryParams = {},
+  requestHeaders = null,
+  responseHeaders = null
+) {
+  if (destinationUrl !== null) {
+    queryParams.d = destinationUrl;
+  }
+
+  // Add headers if provided
+  if (requestHeaders) {
+    Object.entries(requestHeaders).forEach(([key, value]) => {
+      queryParams[`h_${key}`] = value;
+    });
+  }
+  if (responseHeaders) {
+    Object.entries(responseHeaders).forEach(([key, value]) => {
+      queryParams[`r_${key}`] = value;
+    });
+  }
+
+  const encodedParams = new URLSearchParams(queryParams).toString();
+
+  // Construct the full URL
+  const baseUrl = new URL(endpoint, mediaflowProxyUrl).toString();
+  return `${baseUrl}?${encodedParams}`;
+}
+
+export async function updateUserConfigWithMediaFlowIp(userConfig){
+  if (userConfig.enableMediaFlow && userConfig.mediaflowProxyUrl && userConfig.mediaflowApiPassword) {
+    const mediaflowPublicIp = await getMediaflowProxyPublicIp(userConfig);
+    if (mediaflowPublicIp) {
+      userConfig.ip = mediaflowPublicIp;
+    }
+  }
+  return userConfig;
+}
+
+
+export function applyMediaflowProxyIfNeeded(videoUrl, userConfig) {
+  if (userConfig.enableMediaFlow && userConfig.mediaflowProxyUrl && userConfig.mediaflowApiPassword) {
+    return encodeMediaflowProxyUrl(
+      userConfig.mediaflowProxyUrl,
+      "/proxy/stream",
+      videoUrl,
+      {
+        api_password: userConfig.mediaflowApiPassword
+      },
+      null,
+      {
+        "Content-Disposition": `attachment; filename=${path.basename(videoUrl)}`
+      }
+    );
+  }
+  return videoUrl;
+}

src/lib/meta.js

@@ -0,0 +1,17 @@
+import config from './config.js';
+import Cinemeta from './meta/cinemeta.js';
+import Tmdb from './meta/tmdb.js';
+
+const client = config.tmdbAccessToken ? new Tmdb() : new Cinemeta();
+
+export async function getMovieById(id, language){
+  return client.getMovieById(id, language);
+}
+
+export async function getEpisodeById(id, season, episode, language){
+  return client.getEpisodeById(id, season, episode, language);
+}
+
+export async function getLanguages(){
+  return client.getLanguages();
+}

src/lib/meta/cinemeta.js

@@ -0,0 +1,87 @@
+import cache from '../cache.js';
+
+export default class Cinemeta {
+
+  static id = 'cinemeta';
+  static name = 'Cinemeta';
+
+  async getMovieById(id){
+    
+    const data = await this.#request('GET', `/meta/movie/${id}.json`, {}, {key: id, ttl: 3600*3});
+    const meta = data.meta;
+
+    return {
+      name: meta.name,
+      year: parseInt(meta.releaseInfo),
+      imdb_id: meta.imdb_id,
+      type: 'movie',
+      stremioId: id,
+      id,
+    };
+
+  }
+
+  async getEpisodeById(id, season, episode){
+
+    const data = await this.#request('GET', `/meta/series/${id}.json`, {}, {key: id, ttl: 3600*3});
+    const meta = data.meta;
+
+    return {
+      name: meta.name,
+      year: parseInt(`${meta.releaseInfo}`.split('-').shift()),
+      imdb_id: meta.imdb_id,
+      type: 'series',
+      stremioId: `${id}:${season}:${episode}`,
+      id,
+      season,
+      episode,
+      episodes: meta.videos.map(video => {
+        return {
+          season: video.season,
+          episode: video.number,
+          stremioId: video.id
+        }
+      })
+    };
+
+  }
+
+  async getLanguages(){
+    return [];
+  }
+
+  async #request(method, path, opts, cacheOpts){
+
+    cacheOpts = Object.assign({key: '', ttl: 0}, cacheOpts || {});
+    opts = opts || {};
+    opts = Object.assign(opts, {
+      method,
+      headers: Object.assign(opts.headers || {}, {
+        'accept': 'application/json'
+      })
+    });
+
+    let data;
+
+    if(cacheOpts.key){
+      data = await cache.get(`cinemeta:${cacheOpts.key}`);
+      if(data)return data;
+    }
+
+    const url = `https://v3-cinemeta.strem.io${path}?${new URLSearchParams(opts.query).toString()}`;
+    const res = await fetch(url, opts);
+    data = await res.json();
+
+    if(!res.ok){
+      throw new Error(`Invalid Cinemeta api result: ${JSON.stringify(data)}`);
+    }
+
+    if(data && cacheOpts.key && cacheOpts.ttl > 0){
+      await cache.set(`cinemeta:${cacheOpts.key}`, data, {ttl: cacheOpts.ttl})
+    }
+
+    return data;
+
+  }
+
+}

src/lib/meta/tmdb.js

@@ -0,0 +1,244 @@
+import cache from '../cache.js';
+import config from '../config.js';
+
+export default class Tmdb {
+
+  static id = 'tmdb';
+  static name = 'The Movie Database';
+
+  #cleanTmdbId(id) {
+    return id.replace(/^tmdb-/, '');
+  }
+
+  #getSearchTitle(title) {
+    // Special handling for UFC events
+    const ufcMatch = title.match(/UFC Fight Night (\d+):/i) || title.match(/UFC (\d+):/i);
+    if (ufcMatch) {
+      return `UFC ${ufcMatch[1]}`;
+    }
+    return title;
+  }
+
+  async getMovieById(id, language){
+    if (id.startsWith('tmdb-')) {
+      try {
+        const cleanId = this.#cleanTmdbId(id);
+        const movie = await this.#request('GET', `/3/movie/${cleanId}`, {
+          query: {
+            language: language || 'en-US'
+          }
+        }, {
+          key: `movie:${cleanId}:${language || '-'}`,
+          ttl: 3600*3
+        });
+
+        return {
+          name: this.#getSearchTitle(language ? movie.title || movie.original_title : movie.original_title || movie.title),
+          originalName: language ? movie.title || movie.original_title : movie.original_title || movie.title,
+          year: parseInt(`${movie.release_date}`.split('-').shift()),
+          imdb_id: movie.imdb_id || id,
+          type: 'movie',
+          stremioId: id,
+          id,
+        };
+      } catch (err) {
+        console.log(`Failed to fetch movie directly with TMDB ID ${id}:`, err.message);
+      }
+    }
+    
+    // Fallback to IMDb lookup
+    const searchId = await this.#request('GET', `/3/find/${id}`, {
+      query: {
+        external_source: 'imdb_id',
+        language: language || 'en-US'
+      }
+    }, {
+      key: `searchId:${id}:${language || '-'}`,
+      ttl: 3600*3
+    });
+    
+    if (!searchId.movie_results?.[0]) {
+      throw new Error(`Movie not found: ${id}`);
+    }
+    
+    const meta = searchId.movie_results[0];
+
+    return {
+      name: this.#getSearchTitle(language ? meta.title || meta.original_title : meta.original_title || meta.title),
+      originalName: language ? meta.title || meta.original_title : meta.original_title || meta.title,
+      year: parseInt(`${meta.release_date}`.split('-').shift()),
+      imdb_id: id,
+      type: 'movie',
+      stremioId: id,
+      id,
+    };
+  }
+
+  async getEpisodeById(id, season, episode, language){
+    if (id.startsWith('tmdb-')) {
+      try {
+        const cleanId = this.#cleanTmdbId(id);
+        const show = await this.#request('GET', `/3/tv/${cleanId}`, {
+          query: {
+            language: language || 'en-US'
+          }
+        }, {
+          key: `tv:${cleanId}:${language || '-'}`,
+          ttl: 3600*3
+        });
+
+        const episodes = [];
+        show.seasons.forEach(s => {
+          for(let e = 1; e <= s.episode_count; e++){
+            episodes.push({
+              season: s.season_number,
+              episode: e,
+              stremioId: `${id}:${s.season_number}:${e}`
+            });
+          }
+        });
+
+        return {
+          name: this.#getSearchTitle(language ? show.name || show.original_name : show.original_name || show.name),
+          originalName: language ? show.name || show.original_name : show.original_name || show.name,
+          year: parseInt(`${show.first_air_date}`.split('-').shift()),
+          imdb_id: show.external_ids?.imdb_id || id,
+          type: 'series',
+          stremioId: `${id}:${season}:${episode}`,
+          id,
+          season,
+          episode,
+          episodes
+        };
+      } catch (err) {
+        console.log(`Failed to fetch show directly with TMDB ID ${id}:`, err.message);
+      }
+    }
+
+    const searchId = await this.#request('GET', `/3/find/${id}`, {
+      query: {
+        external_source: 'imdb_id'
+      }
+    }, {
+      key: `searchId:${id}`,
+      ttl: 3600*3
+    });
+
+    if (!searchId.tv_results?.[0]) {
+      throw new Error(`TV series not found: ${id}`);
+    }
+
+    const meta = await this.#request('GET', `/3/tv/${searchId.tv_results[0].id}`, {
+      query: {
+        language: language || 'en-US'
+      }
+    }, {
+      key: `${id}:${language}`,
+      ttl: 3600*3
+    });
+
+    const episodes = [];
+    meta.seasons.forEach(s => {
+      for(let e = 1; e <= s.episode_count; e++){
+        episodes.push({
+          season: s.season_number,
+          episode: e,
+          stremioId: `${id}:${s.season_number}:${e}`
+        });
+      }
+    });
+
+    return {
+      name: this.#getSearchTitle(language ? meta.name || meta.original_name : meta.original_name || meta.name),
+      originalName: language ? meta.name || meta.original_name : meta.original_name || meta.name,
+      year: parseInt(`${meta.first_air_date}`.split('-').shift()),
+      imdb_id: id,
+      type: 'series',
+      stremioId: `${id}:${season}:${episode}`,
+      id,
+      season,
+      episode,
+      episodes
+    };
+  }
+
+  async getLanguages(){
+    return [{value: '', label: '🌎Original (Recommended)'}].concat(
+      ...config.languages
+        .map(language => ({value: language.iso639, label: language.label}))
+        .filter(language => language.value)
+    );
+  }
+
+  async #request(method, path, opts = {}, cacheOpts = {}) {
+    const apiKey = config.tmdbAccessToken;
+
+    // Normalize cache options
+    cacheOpts = {
+      key: '',
+      ttl: 0,
+      ...cacheOpts
+    };
+
+    // Check cache first
+    if (cacheOpts.key) {
+      const cached = await cache.get(`tmdb:${cacheOpts.key}`);
+      if (cached) return cached;
+    }
+
+    // Clean up the path - remove any trailing slashes
+    path = path.replace(/\/+$/, '');
+
+    // Prepare query parameters including API key
+    const queryParams = new URLSearchParams({
+      api_key: apiKey,
+      ...(opts.query || {})
+    });
+
+    // Build the complete URL
+    const url = `https://api.themoviedb.org${path}?${queryParams}`;
+
+    // Prepare request options
+    const requestOpts = {
+      method,
+      headers: {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json;charset=utf-8',
+        ...opts.headers
+      }
+    };
+
+    // Debug log the full URL
+    console.log('TMDB Request URL:', url);
+    console.log('TMDB Request Headers:', requestOpts.headers);
+
+    try {
+      const res = await fetch(url, requestOpts);
+      const data = await res.json();
+
+      // Debug log the response
+      console.log('TMDB Response Status:', res.status);
+      console.log('TMDB Response Data:', JSON.stringify(data, null, 2));
+
+      if (!res.ok) {
+        console.error('TMDB API Error:', {
+          status: res.status,
+          url: url,
+          headers: requestOpts.headers,
+          response: data
+        });
+        throw new Error(`TMDB API error: ${data.status_message || 'Unknown error'}`);
+      }
+
+      // Cache successful response if needed
+      if (cacheOpts.key && cacheOpts.ttl > 0) {
+        await cache.set(`tmdb:${cacheOpts.key}`, data, {ttl: cacheOpts.ttl});
+      }
+
+      return data;
+    } catch (error) {
+      console.error('TMDB Request failed:', error);
+      throw error;
+    }
+  }
+}

src/lib/torrentInfos.js

@@ -0,0 +1,182 @@
+import crypto from 'crypto';
+import path from 'path';
+import { writeFile, readFile, mkdir, readdir, unlink, stat } from 'node:fs/promises';
+import parseTorrent from 'parse-torrent';
+import {toMagnetURI} from 'parse-torrent';
+import cache from './cache.js';
+import config from './config.js';
+
+const TORRENT_FOLDER = `${config.dataFolder}/torrents`;
+const CACHE_FILE_DAYS = 7;
+
+export async function createTorrentFolder(){
+  return mkdir(TORRENT_FOLDER).catch(() => false);
+}
+
+export async function cleanTorrentFolder(){
+  const files = await readdir(TORRENT_FOLDER);
+  const expireTime = new Date().getTime() - 86400*CACHE_FILE_DAYS*1000;
+  for (const file of files) {
+    if(!file.endsWith('.torrent'))continue;
+    const filePath = path.join(TORRENT_FOLDER, file);
+    const stats = await stat(filePath);
+    if(stats.ctimeMs < expireTime){
+      await unlink(filePath);
+    }
+  }
+}
+
+export async function get({link, id, magnetUrl, infoHash, name, size, type}){
+
+  try {
+    return await getById(id);
+  }catch(err){}
+
+  let parseInfos = null;
+  let torrentLocation = '';
+
+  if(magnetUrl && infoHash && name && size > 0 && type){
+
+    parseInfos = {
+      infoHash, 
+      name, 
+      length: size, 
+      private: (type == 'private')
+    };
+
+  }else{
+
+    if(link.startsWith('http')){
+
+      try {
+
+        torrentLocation = `${TORRENT_FOLDER}/${id}.torrent`;
+        const buffer = await downloadTorrentFile({link, id, torrentLocation});
+        parseInfos = await parseTorrent(new Uint8Array(buffer));
+
+        if(!parseInfos.private){
+          magnetUrl = toMagnetURI(parseInfos);
+        }
+
+      }catch(err){
+
+        torrentLocation = '';
+        if(err.redirection && err.redirection.startsWith('magnet')){
+          link = err.redirection;
+        }else{
+          // Add indexer info to error message if available
+          const errorMessage = err.message + (err.indexerId ? ` (Indexer: ${err.indexerId})` : '');
+          throw new Error(errorMessage);
+        }
+
+      }
+
+    }
+
+    if(link.startsWith('magnet')){
+
+      parseInfos = await parseTorrent(link);
+      magnetUrl = link;
+
+    }
+
+  }
+
+  if(!parseInfos){
+    throw new Error(`Invalid link ${link}`);
+  }
+
+  const torrentInfos = {
+    id,
+    link,
+    magnetUrl: magnetUrl || '',
+    torrentLocation,
+    infoHash: (parseInfos.infoHash || '').toLowerCase(),
+    name: parseInfos.name || '',
+    private: parseInfos.private || false,
+    size: parseInfos.length || -1,
+    files: (parseInfos.files || []).map(file => {
+      return {
+        name: file.name,
+        size: file.length
+      }
+    })
+  };
+
+  await setById(id, torrentInfos);
+
+  return torrentInfos;
+
+}
+
+export async function getById(id){
+  const cacheKey = `torrentInfos:${id}`;
+  const infos = await cache.get(cacheKey);
+
+  if(!infos){
+    throw new Error(`Torrent infos cache seem expired for id ${id}`);
+  }
+
+  return infos;
+}
+
+async function setById(id, infos){
+  const cacheKey = `torrentInfos:${id}`;
+  await cache.set(cacheKey, infos, {ttl: 86400*CACHE_FILE_DAYS});
+  return infos;
+}
+
+export async function getTorrentFile(infos){
+  if(infos.torrentLocation){
+    try {
+      return await readFile(infos.torrentLocation);
+    }catch(err){}
+  }
+
+  return downloadTorrentFile(infos);
+}
+
+async function downloadTorrentFile({link, id, torrentLocation, indexerId}){
+  const res = await fetch(link, {redirect: 'manual'});
+
+  // Handle redirections
+  if(res.headers.has('location')){
+    throw Object.assign(new Error(`Redirection detected ...`), {redirection: res.headers.get('location')});
+  }
+
+  const contentType = res.headers.get('content-type') || '';
+
+  // Check if we got an HTML response (usually an error page)
+  if(contentType.includes('text/html')){
+    const htmlContent = await res.text();
+    let errorMessage = 'Site returned an error page';
+    
+    // Try to extract meaningful error messages
+    if(htmlContent.includes('ratio is dangerously low')){
+      errorMessage = 'Download blocked due to low ratio';
+    }else if(htmlContent.includes('do not have permission')){
+      errorMessage = 'Permission denied';
+    }
+    // Add indexer information to error
+    throw Object.assign(new Error(errorMessage), { indexerId });
+  }
+
+  // Verify we got a torrent file
+  if(!contentType.includes('application/x-bittorrent')){
+    throw Object.assign(
+      new Error(`Invalid content-type: ${contentType}`),
+      { indexerId }
+    );
+  }
+
+  if(res.status != 200){
+    throw Object.assign(
+      new Error(`Invalid status: ${res.status}`),
+      { indexerId }
+    );
+  }
+
+  const buffer = await res.arrayBuffer();
+  writeFile(torrentLocation, new Uint8Array(buffer));
+  return buffer;
+}

src/lib/util.js

@@ -0,0 +1,63 @@
+import {setTimeout} from 'timers/promises';
+
+export function numberPad(number, count){
+  return `${number}`.padStart(count || 2, 0);
+}
+
+export function parseWords(str){
+  return str.replace(/[^a-zA-Z0-9]+/g, ' ').split(' ').filter(Boolean);
+}
+
+export function sortBy(...keys){
+  return (a, b) => {
+    if(typeof(keys[0]) == 'string')keys = [keys];
+    for(const [key, reverse] of keys){
+      if(a[key] > b[key])return reverse ? -1 : 1;
+      if(a[key] < b[key])return reverse ? 1 : -1;
+    }
+    return 0;
+  }
+}
+
+export function bytesToSize(bytes){
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+  if (bytes === 0) return '0 Byte';
+  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)));
+  return (Math.round(bytes / Math.pow(1024, i) * 100) / 100) + ' ' + sizes[i];
+}
+
+export function wait(ms){
+  return setTimeout(ms);
+}
+
+export function isVideo(filename){
+  return [
+    "3g2",
+    "3gp",
+    "avi",
+    "flv",
+    "mkv",
+    "mk3d",
+    "mov",
+    "mp2",
+    "mp4",
+    "m4v",
+    "mpe",
+    "mpeg",
+    "mpg",
+    "mpv",
+    "webm",
+    "wmv",
+    "ogm",
+    "ts",
+    "m2ts"
+  ].includes(filename?.split('.').pop());
+}
+
+export async function promiseTimeout(promise, ms){
+  const ac = new AbortController();
+  const waitPromise = setTimeout(ms, null, { signal: ac.signal }).then(() => Promise.reject(`Max execution time reached ${ms}`));
+  return Promise.race([waitPromise, promise.finally(() => {
+    ac.abort();
+  })]);
+}

src/template/configure.html

@@ -0,0 +1,310 @@
+<!doctype html>
+<html lang="en" data-bs-theme="dark">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Jackettio</title>
+    <link rel="icon" href="/icon">
+    <link href="/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-T3c6CoIi6uLrA9TneNEoa7RxnatzjcDSCmG1MXxSR1GAsXEV/Dwwykc2MPK8M2HN" crossorigin="anonymous">
+    <style>
+      .container {
+        max-width: 600px;
+      }
+      [v-cloak] { display: none; }
+    </style>
+  </head>
+  <body id="app">
+    <div class="container my-5" v-cloak>
+      <h1 class="mb-4">{{addon.name}} <span style="font-size:.6em">v{{addon.version}}</span></h1>
+      <form class="shadow p-3 bg-dark-subtle z-3 rounded">
+
+        <!-- welcome-message -->
+
+        <h5 class="mt-4">Indexers</h5>
+        <div class="ps-2 border-start border-secondary-subtle">
+          <div class="mb-3 alert alert-warning" v-if="indexers.length == 0">
+            No indexers available, Jackett instance does not seem to be configured correctly.
+          </div>
+          <div class="mb-3" v-if="indexers.length >= 1 && !immulatableUserConfigKeys.includes('indexers')">
+            <label>Indexers enabled:</label>
+            <div class="d-flex flex-wrap">
+              <div v-for="indexer in indexers" class="me-3" :title="indexer.types.join(', ')">
+                <input class="form-check-input me-1" type="checkbox" v-model="indexer.checked" :id="indexer.label">
+                <label class="form-check-label" :for="indexer.label">{{indexer.label}}</label>
+              </div>
+            </div>
+          </div>
+          <div class="mb-3" v-if="!immulatableUserConfigKeys.includes('indexerTimeoutSec')">
+            <label>Indexer Timeout</label>
+            <input type="number" v-model="form.indexerTimeoutSec" min="6" max="120" class="form-control">
+            <small class="text-muted">Max execution time in seconds before timeout.</small>
+          </div>
+          <div class="mb-3" v-if="passkey && passkey.enabled">
+            <label>Private indexer Passkey <i>(Recommended)</i></label>
+            <small v-if="passkey.infoUrl" class="ms-2"><a :href="passkey.infoUrl" target="_blank" rel="noreferrer">Get It here</a></small>
+            <input type="text" v-model="form.passkey" class="form-control" :pattern="passkey.pattern">
+            <small class="text-muted">With the Passkey you can stream both cached and uncached torrents, while without the Passkey you can only stream cached torrents.</small>
+          </div>
+        </div>
+
+        <h5 class="mt-4">Filters & Sorts</h5>
+        <div class="ps-2 border-start border-secondary-subtle">
+          <div class="mb-3" v-if="!immulatableUserConfigKeys.includes('qualities')">
+            <label>Qualities:</label>
+            <div class="d-flex flex-wrap">
+              <div v-for="quality in qualities" class="me-3">
+                <input class="form-check-input me-1" type="checkbox" v-model="quality.checked" :id="quality.label">
+                <label class="form-check-label" :for="quality.label">{{quality.label}}</label>
+              </div>
+            </div>
+          </div>
+          <div class="mb-3" v-if="!immulatableUserConfigKeys.includes('excludeKeywords')">
+            <label>Exclude keywords in torrent name</label>
+            <input type="text" v-model="form.excludeKeywords" placeholder="keyword1,keyword2" class="form-control">
+            <small class="text-muted">Example: cam,xvid</small>
+          </div>
+          <div class="mb-3 d-flex flex-row" v-if="!immulatableUserConfigKeys.includes('hideUncached')">
+            <div class="form-check form-switch">
+              <input class="form-check-input me-1" type="checkbox" v-model="form.hideUncached" id="hideUncached">
+              <label for="hideUncached" class="d-flex flex-column">
+                <span>Display only cached torrents</span>
+              </label>
+            </div>
+          </div>
+          <div class="mb-3" v-if="!immulatableUserConfigKeys.includes('sortCached')">
+            <label>Cached torrents sorting</label>
+            <select v-model="form.sortCached" class="form-select">
+              <option v-for="sort in sorts" :value="sort.value">{{sort.label}}</option>
+            </select>
+          </div>
+          <div class="mb-3" v-if="!immulatableUserConfigKeys.includes('sortUncached') && !form.hideUncached">
+            <label>Uncached torrents sorting</label>
+            <select v-model="form.sortUncached" class="form-select">
+              <option v-for="sort in sorts" :value="sort.value">{{sort.label}}</option>
+            </select>
+          </div>
+          <div class="mb-3" v-if="!immulatableUserConfigKeys.includes('maxTorrents')">
+            <label>Max Torrents in search</label>
+            <input type="number" v-model="form.maxTorrents" min="1" max="30" class="form-control">
+            <small class="text-muted">A high number can significantly slow down the request</small>
+          </div>
+          <div class="mb-3" v-if="!immulatableUserConfigKeys.includes('priotizePackTorrents')">
+            <label>Force include <small>n</small> series pack in search</label>
+            <input type="number" v-model="form.priotizePackTorrents" min="1" max="30" class="form-control">
+            <small class="text-muted">This could increase the chance of cached torrents. 2 is a good number</small>
+          </div>
+          <div class="mb-3" v-if="!immulatableUserConfigKeys.includes('priotizeLanguages')">
+            <label>Priotize audio languages</label>
+            <select v-model="form.priotizeLanguages" class="form-select" multiple>
+              <option v-for="language in languages" :value="language.value">{{language.label}}</option>
+            </select>
+          </div>
+          <div class="mb-3" v-if="!immulatableUserConfigKeys.includes('metaLanguage') && metaLanguages.length > 0">
+            <label>Search languages</label>
+            <select v-model="form.metaLanguage" class="form-select">
+              <option v-for="metaLanguage in metaLanguages" :value="metaLanguage.value">{{metaLanguage.label}}</option>
+            </select>
+            <small class="text-muted">By default, the search uses the original title and works in most cases, but you can force the search to use a specific language.</small>
+          </div>
+        </div>
+
+        <h5 class="mt-4">Debrid</h5>
+        <div class="ps-2 border-start border-secondary-subtle">
+          <div class="mb-3 d-flex flex-row" v-if="!immulatableUserConfigKeys.includes('forceCacheNextEpisode')">
+            <div class="form-check form-switch">
+              <input class="form-check-input me-1" type="checkbox" v-model="form.forceCacheNextEpisode" id="forceCacheNextEpisode">
+              <label for="forceCacheNextEpisode" class="d-flex flex-column">
+                <span>Prepare the next episode on Debrid. (Recommended)</span>
+                <small class="text-muted">Automatically add the next espisode on debrid when not avaiable to instantally stream it later.</small>
+              </label>
+            </div>
+          </div>
+          <div class="mb-3">
+            <label>Debrid provider:</label>
+            <select v-model="debrid" class="form-select" @change="form.debridId = debrid.id">
+              <option v-for="option in debrids" :value="option">{{ option.name }}</option>
+            </select>
+          </div>
+          <div v-for="field in debrid.configFields" class="mb-3">
+            <label>{{field.label}}:</label> 
+            <small v-if="field.href" class="ms-2"><a :href="field.href.value" target="_blank" rel="noreferrer">{{field.href.label}}</a></small>
+            <input type="{{field.type}}" v-model="field.value" class="form-control">
+          </div>
+        </div>
+
+        <h5 class="mt-4">MediaFlow Proxy</h5>
+        <div class="ps-2 border-start border-secondary-subtle">
+          <div class="mb-3" v-if="!immulatableUserConfigKeys.includes('enableMediaFlow')">
+            <div class="form-check form-switch">
+              <input class="form-check-input" type="checkbox" v-model="form.enableMediaFlow" id="enableMediaFlow">
+              <label class="form-check-label" for="enableMediaFlow">Enable MediaFlow Proxy</label>
+            </div>
+          </div>
+          <div v-if="form.enableMediaFlow">
+            <div class="mb-2">
+              <a href="https://github.com/mhdzumair/mediaflow-proxy?tab=readme-ov-file#mediaflow-proxy" target="_blank" rel="noopener">
+                MediaFlow Setup Guide
+              </a>
+            </div>
+            <div class="mb-3" v-if="!immulatableUserConfigKeys.includes('mediaflowProxyUrl')">
+              <label for="mediaflowProxyUrl">MediaFlow Proxy URL:</label>
+              <input type="text" v-model="form.mediaflowProxyUrl" class="form-control" id="mediaflowProxyUrl" placeholder="https://your-mediaflow-proxy-url.com">
+            </div>
+            <div class="mb-3" v-if="!immulatableUserConfigKeys.includes('mediaflowApiPassword')">
+              <label for="mediaflowApiPassword">MediaFlow API Password:</label>
+              <div class="input-group">
+                <input :type="showMediaFlowPassword ? 'text' : 'password'" v-model="form.mediaflowApiPassword" class="form-control" id="mediaflowApiPassword">
+                <button class="btn btn-outline-secondary" type="button" @click="toggleMediaFlowPassword">
+                  <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-eye" viewBox="0 0 16 16" v-if="showMediaFlowPassword">
+                    <path d="M16 8s-3-5.5-8-5.5S0 8 0 8s3 5.5 8 5.5S16 8 16 8M1.173 8a13 13 0 0 1 1.66-2.043C4.12 4.668 5.88 3.5 8 3.5s3.879 1.168 5.168 2.457A13 13 0 0 1 14.828 8q-.086.13-.195.288c-.335.48-.83 1.12-1.465 1.755C11.879 11.332 10.119 12.5 8 12.5s-3.879-1.168-5.168-2.457A13 13 0 0 1 1.172 8z"/>
+                    <path d="M8 5.5a2.5 2.5 0 1 0 0 5 2.5 2.5 0 0 0 0-5M4.5 8a3.5 3.5 0 1 1 7 0 3.5 3.5 0 0 1-7 0"/>
+                  </svg>
+                  <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-eye-slash-fill" viewBox="0 0 16 16" v-else>
+                    <path d="m10.79 12.912-1.614-1.615a3.5 3.5 0 0 1-4.474-4.474l-2.06-2.06C.938 6.278 0 8 0 8s3 5.5 8 5.5a7 7 0 0 0 2.79-.588M5.21 3.088A7 7 0 0 1 8 2.5c5 0 8 5.5 8 5.5s-.939 1.721-2.641 3.238l-2.062-2.062a3.5 3.5 0 0 0-4.474-4.474z"/>
+                    <path d="M5.525 7.646a2.5 2.5 0 0 0 2.829 2.829zm4.95.708-2.829-2.83a2.5 2.5 0 0 1 2.829 2.829zm3.171 6-12-12 .708-.708 12 12z"/>
+                  </svg>
+                </button>
+              </div>
+            </div>
+            <div class="mb-3" v-if="!immulatableUserConfigKeys.includes('mediaflowPublicIp')">
+              <label for="mediaflowPublicIp">MediaFlow Public IP (Optional):</label>
+              <input type="text" v-model="form.mediaflowPublicIp" class="form-control" id="mediaflowPublicIp" placeholder="Enter public IP address">
+              <small class="text-muted">
+                Configure this only when running MediaFlow locally with a proxy service. Leave empty if MediaFlow is configured locally without a proxy server or if it's hosted on a remote server.
+              </small>
+            </div>
+          </div>
+        </div>
+
+        <div class="my-3 d-flex align-items-center">
+          <button @click="configure" type="button" class="btn btn-primary" :disabled="!debrid.id">{{isUpdate ? 'Update' : 'Install'}}</button>
+          <div v-if="error" class="text-danger ms-2">{{error}}</div>
+          <div class="ms-auto">
+            <a v-if="manifestUrl" :href="manifestUrl">Stremio Link</a>
+          </div>
+        </div>
+
+      </form>
+    </div>
+
+    <script src="/js/vue.global.prod.js"></script>
+    <script type="text/javascript">/** import-config */</script>
+    <script type="text/javascript">
+      const { createApp, ref } = Vue
+      createApp({
+        setup() {
+
+          const {addon, debrids, defaultUserConfig, qualities, languages, sorts, indexers, passkey, immulatableUserConfigKeys, metaLanguages} = config;
+
+          const debrid = ref({});
+          const error = ref('');
+          const manifestUrl = ref('');
+          let isUpdate = false;
+          const showMediaFlowPassword = ref(false);
+
+          function toggleMediaFlowPassword() {
+            showMediaFlowPassword.value = !showMediaFlowPassword.value;
+          }
+
+          if(config.userConfig){
+            try {
+              const savedUserConfig = JSON.parse(atob(config.userConfig));
+              Object.assign(defaultUserConfig, savedUserConfig);
+              debrid.value = debrids.find(debrid => debrid.id == savedUserConfig.debridId) || {};
+              debrid.value.configFields.forEach(field => field.value = savedUserConfig[field.name] || null);
+              isUpdate = true;
+            }catch(err){}
+          }
+
+          const form = ref({
+            maxTorrents: defaultUserConfig.maxTorrents,
+            priotizePackTorrents: defaultUserConfig.priotizePackTorrents,
+            excludeKeywords: defaultUserConfig.excludeKeywords.join(','),
+            debridId: defaultUserConfig.debridId || '',
+            hideUncached: defaultUserConfig.hideUncached,
+            sortCached: defaultUserConfig.sortCached,
+            sortUncached: defaultUserConfig.sortUncached,
+            forceCacheNextEpisode: defaultUserConfig.forceCacheNextEpisode,
+            priotizeLanguages: defaultUserConfig.priotizeLanguages,
+            indexerTimeoutSec: defaultUserConfig.indexerTimeoutSec,
+            metaLanguage: defaultUserConfig.metaLanguage,
+            enableMediaFlow: defaultUserConfig.enableMediaFlow,
+            mediaflowProxyUrl: defaultUserConfig.mediaflowProxyUrl,
+            mediaflowApiPassword: defaultUserConfig.mediaflowApiPassword,
+            mediaflowPublicIp: defaultUserConfig.mediaflowPublicIp
+          });
+
+          qualities.forEach(quality => quality.checked = defaultUserConfig.qualities.includes(quality.value));
+          indexers.forEach(indexer => indexer.checked = defaultUserConfig.indexers.includes(indexer.value) || defaultUserConfig.indexers.includes('all'));
+
+          async function configure(){
+            try {
+              error.value = '';
+              const userConfig = Object.assign({}, form.value);
+              userConfig.qualities = qualities.filter(quality => quality.checked).map(quality => quality.value);
+              userConfig.indexers = indexers.filter(indexer => indexer.checked).map(indexer => indexer.value);
+              userConfig.excludeKeywords = form.value.excludeKeywords.split(',').filter(Boolean);
+              debrid.value.configFields.forEach(field => {
+                if(field.required && !field.value)throw new Error(`${field.label} is required`);
+                userConfig[field.name] = field.value
+              });
+
+              if(!userConfig.debridId){
+                throw new Error(`Debrid is required`);
+              }
+
+              if(!userConfig.qualities.length){
+                throw new Error(`Quality is required`);
+              }
+
+              if(!userConfig.indexers.length && indexers.length){
+                throw new Error(`Indexer is required`);
+              }
+
+              if(passkey.enabled){
+                if(userConfig.passkey && !userConfig.passkey.match(new RegExp(passkey.pattern))){
+                  throw new Error(`Tracker passkey have invalid format: ${passkey.pattern}`);
+                }
+              }
+
+              // MediaFlow config validation
+              if (userConfig.enableMediaFlow) {
+                if (!userConfig.mediaflowProxyUrl) {
+                  throw new Error('MediaFlow Proxy URL is required when MediaFlow is enabled');
+                }
+                if (!userConfig.mediaflowApiPassword) {
+                  throw new Error('MediaFlow API Password is required when MediaFlow is enabled');
+                }
+              }
+
+              manifestUrl.value = `stremio://${document.location.host}/${btoa(JSON.stringify(userConfig))}/manifest.json`;
+              document.location.href = manifestUrl.value;
+            }catch(err){
+              error.value = err.message || err;
+            }
+          }
+
+          return {
+            addon,
+            debrids,
+            debrid,
+            qualities,
+            sorts,
+            form,
+            configure,
+            error,
+            manifestUrl,
+            indexers,
+            passkey,
+            immulatableUserConfigKeys,
+            languages,
+            isUpdate,
+            metaLanguages,
+            showMediaFlowPassword,
+            toggleMediaFlowPassword
+          }
+        }
+      }).mount('#app')
+    </script>
+  </body>
+</html>