vejeta.

en debian · linux

De la documentación a la distribución: el viaje completo del empaquetado de Stremio para Debian

Publicado Actualizado ES

Cómo una sencilla contribución a la documentación se convirtió en una solución de empaquetado completa, con CI/CD automatizado, soporte para varias distribuciones y resolución de problemas técnicos a fondo

Autor: Juan Manuel Méndez Rey
Fecha: 30 de octubre de 2025
Tiempo de lectura: 25 minutos
Nivel técnico: avanzado

El principio: un hueco en la documentación

Hace unos años, mientras trabajaba con Stremio en sistemas Debian, me encontré con la frustración de siempre de los usuarios de Linux de todas partes: una aplicación estupenda con una documentación de instalación pobre. Las publicaciones oficiales de Stremio funcionaban bien en algunas distribuciones, pero los usuarios de Debian tenían que apañarse solos con las dependencias, los pasos de compilación y los problemas de integración.

Fue entonces cuando contribuí el fichero DEBIAN.md original al repositorio de Stremio shell. Era una guía de compilación directa: instala estas dependencias, ejecuta estos comandos, copia estos ficheros. Sencilla, pero funcional.

Pasaron los años. Las dependencias cambiaron. Las versiones de Qt evolucionaron. Las instrucciones sencillas de compilación se volvieron cada vez menos fiables en los sistemas Debian modernos, y los issues de GitHub se llenaron de usuarios frustrados que no conseguían compilar Stremio.

El problema crece

En 2025 la situación ya era insostenible:

  • Conflictos de dependencias: el paquete .deb de upstream requería libmpv1, pero el Debian moderno trae libmpv2
  • Violaciones del FHS: upstream lo instalaba todo en /opt, incumpliendo los estándares del sistema de ficheros de Debian
  • Módulos QML ausentes: componentes críticos de Qt5 no estaban documentados como dependencias
  • Complejidad de la compilación: los usuarios tenían que instalar más de 15 dependencias de compilación para compilar desde el fuente
  • Sin una integración adecuada: los ficheros de escritorio, los iconos y la integración con el sistema requerían trabajo manual
  • El paquete .deb de upstream está desactualizado, ofrece la versión 4.4.168.
  • Y la lista sigue…

Los issues de GitHub eran buena prueba de la frustración de los usuarios: decenas de informes sobre fallos de compilación, dependencias ausentes e instalaciones rotas.

El modo Debian: empaquetar como es debido

En vez de seguir parcheando la documentación, me acordé de una conversación con mi amigo Arturo sobre empaquetar Stremio para Debian como es debido. Él creó un RFP (Request for Package) de Stremio en 2020. Pasaron los años y seguí con mi trabajo del día a día.
El mes pasado decidí que tenía que cumplir mi viejo sueño de ser colaborador oficial de Debian, así que decidí resolver esto como es debido a través del sistema de empaquetado de Debian. A finales de 2025 abrí un Intent To Package (ITP) en Debian:

El objetivo era sencillo: crear paquetes de Debian bien empaquetados que acabaran entrando en el archivo oficial de Debian.

Retos del empaquetado

Stremio plantea retos de empaquetado particulares:

  1. Separación de licencias: el cliente de escritorio es GPL-3.0 (libre), pero el servidor de streaming es propietario
  2. Dependencias modernas: requiere versiones actuales de Qt5 WebEngine y de libmpv
  3. Sistema de compilación complejo: componentes de Qt5 + Node.js + WebAssembly
  4. Integración de escritorio: instalación correcta de iconos, tipos MIME y ficheros .desktop
  5. Dependencias incluidas: upstream usaba submódulos de git para todo

Siguiendo la política de Debian, separé los componentes:

  • Paquete stremio (main/free): cliente de escritorio GPL v4.4.169
  • Paquete stremio-server (non-free): servidor de streaming propietario v4.20.12

A fondo: migración a las bibliotecas del sistema

Lo más difícil fue sustituir TODOS los submódulos de git incluidos por bibliotecas del sistema de Debian. No era solo cuestión de dependencias: había que arreglar problemas de fondo en tiempo de ejecución.

Reto 1: fallo al inicializar QtWebEngine 🔥 CRÍTICO

Problema: la aplicación se caía nada más arrancar:

Segmentation fault (core dumped)

Análisis de la causa raíz:

# GDB backtrace showed:
#0  QQmlApplicationEngine::QQmlApplicationEngine()
#1  main (argc=1, argv=0x7fffffffdc58) at main.cpp:120

QtWebEngine debe inicializarse antes del constructor de QApplication, pero el código de upstream creaba primero QApplication.

Solución: añadí una llamada de inicialización crítica en main.cpp:

#include <QtWebEngine/QtWebEngine>

int main(int argc, char *argv[]) {
    // CRITICAL: Initialize QtWebEngine before QApplication
    QtWebEngine::initialize();

    QApplication app(argc, argv);
    // ... rest of code
}

Impacto: resolvió el 100% de los fallos del motor QML. Esta única línea evita todos los fallos de inicialización de QtWebEngine.

Parche: 0007-add-qtwebengine-initialize-fix.patch

Reto 2: incompatibilidad de hilos de SingleApplication 🔥 CRÍTICO

Problema: el libsingleapplication-dev v3.3.4 del sistema provocaba fallos de segmentación al usarse con QQmlApplicationEngine.

Investigación:

# Test with system library:
sudo apt install libsingleapplication-dev
# Build and run: Segmentation fault

# Test without SingleApplication:
# Remove from CMakeLists.txt: Works perfectly

Causa raíz: la biblioteca del sistema monta un contexto de hilos incompatible con la inicialización del motor QML de Qt5. La biblioteca usa mecanismos internos de hilos que chocan con el bucle de eventos de QQmlApplicationEngine.

Solución: una implementación propia de CompatibleSingleApp. Esto sirve también para sustituir uno de los submódulos incluidos, que hace poco cambió su licencia MIT por una licencia dudosa que podría ser incompatible con las directrices DFSG de Debian. Ver https://github.com/itay-grudev/SingleApplication/issues/210

  • Subclase pura de QApplication
  • IPC mediante QLocalSocket/QLocalServer
  • Sin conflictos de hilos
  • Funcionalidad completa de instancia única

Implementación (compatible_singleapp.h):

#ifndef COMPATIBLE_SINGLEAPP_H
#define COMPATIBLE_SINGLEAPP_H

#include <QApplication>
#include <QLocalServer>
#include <QLocalSocket>

class CompatibleSingleApp : public QApplication {
    Q_OBJECT

public:
    CompatibleSingleApp(int &argc, char **argv, const QString &appId);
    ~CompatibleSingleApp();

    bool isPrimary() const { return m_isPrimary; }
    bool sendMessage(const QString &message);

signals:
    void receivedMessage(const QString &message);

private slots:
    void handleNewConnection();

private:
    bool m_isPrimary;
    QLocalServer *m_server;
    QString m_socketName;
};

#endif

Implementación (compatible_singleapp.cpp):

#include "compatible_singleapp.h"
#include <QLocalSocket>
#include <QCryptographicHash>

CompatibleSingleApp::CompatibleSingleApp(int &argc, char **argv, const QString &appId)
    : QApplication(argc, argv), m_isPrimary(false), m_server(nullptr) {

    // Generate unique socket name
    m_socketName = QString("stremio-") +
        QString::fromUtf8(QCryptographicHash::hash(appId.toUtf8(),
                                                     QCryptographicHash::Sha256).toHex().left(16));

    // Try to connect to existing instance
    QLocalSocket socket;
    socket.connectToServer(m_socketName);

    if (socket.waitForConnected(500)) {
        // Another instance is running
        m_isPrimary = false;
        socket.disconnectFromServer();
        return;
    }

    // We're the primary instance
    m_isPrimary = true;

    // Create server for IPC
    m_server = new QLocalServer(this);
    QLocalServer::removeServer(m_socketName);

    if (m_server->listen(m_socketName)) {
        connect(m_server, &QLocalServer::newConnection,
                this, &CompatibleSingleApp::handleNewConnection);
    }
}

CompatibleSingleApp::~CompatibleSingleApp() {
    if (m_server) {
        m_server->close();
        QLocalServer::removeServer(m_socketName);
    }
}

bool CompatibleSingleApp::sendMessage(const QString &message) {
    if (m_isPrimary) return false;

    QLocalSocket socket;
    socket.connectToServer(m_socketName);

    if (!socket.waitForConnected(1000)) return false;

    QByteArray data = message.toUtf8();
    socket.write(data);
    socket.waitForBytesWritten();
    socket.disconnectFromServer();

    return true;
}

void CompatibleSingleApp::handleNewConnection() {
    QLocalSocket *socket = m_server->nextPendingConnection();

    if (socket) {
        connect(socket, &QLocalSocket::readyRead, this, [this, socket]() {
            QByteArray data = socket->readAll();
            emit receivedMessage(QString::fromUtf8(data));
            socket->deleteLater();
        });
    }
}

Resultados:

  • ✅ Cero conflictos de hilos
  • ✅ Comportamiento completo de instancia única
  • ✅ Paso de mensajes entre instancias
  • ✅ Integración limpia con QQmlApplicationEngine

Parches:

  • 0008-add-compatible-singleapp-implementation.patch
  • 0009-remove-system-singleapplication-add-compatible.patch

Reto 3: variables de entorno de QProcess para el servidor Node.js 🔥 CRÍTICO

Problema: el servidor de streaming no arrancaba y daba un error críptico:

server-crash 0 null
TypeError [ERR_INVALID_ARG_TYPE]: The "path" argument must be of type string. Received undefined
    at Object.join (node:path:1292:7)

Investigación:

# Manual server test works:
$ /usr/bin/node /usr/share/stremio/server.js
EngineFS server started at http://127.0.0.1:11470

# But QProcess launch fails:
timeout 15s stremio
# Error: server-crash 0 null

Causa raíz: QProcess no hereda las variables de entorno por defecto. El server.js de Node.js necesita:

  • HOME: para el directorio de configuración (~/.stremio-server)
  • USER: para identificar el proceso
  • PWD: para resolver rutas relativas

Solución: configuración explícita del entorno en stremioprocess.cpp:

void Process::start(QStringList args) {
    // Set up environment variables for Node.js server
    QProcessEnvironment env = QProcessEnvironment::systemEnvironment();

    // Ensure essential environment variables are set for server.js
    if (!env.contains("HOME")) {
        env.insert("HOME", QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
    }
    if (!env.contains("USER")) {
        env.insert("USER", qgetenv("USER"));
    }
    if (!env.contains("PWD")) {
        env.insert("PWD", QDir::currentPath());
    }

    this->setProcessEnvironment(env);

    // Now start the process
    QProcess::start(this->program(), args);
}

Verificación:

# After fix:
$ timeout 15s build/stremio 2>&1 | grep -A 5 "hls executables"
hls executables located -> { ffmpeg: '/usr/bin/ffmpeg', ffsplit: null }
Using app path -> /home/user/.stremio-server
Enabling casting...
Discovery of new external device "mpv" - MPV
EngineFS server started at http://127.0.0.1:11470

Impacto: la funcionalidad de streaming quedó resuelta por completo. Los usuarios ya pueden reproducir contenido por BitTorrent, usar casting y acceder a todas las funciones del servidor.

Parche: 0011-fix-qprocess-environment-for-server-launch.patch

Reto 4: momento de creación del widget de la bandeja del sistema

Problema: aviso al arrancar:

QWidget: Cannot create a QWidget without QApplication

Causa raíz: el widget SystemTray se creaba antes de que el motor QML estuviera del todo inicializado.

Solución: retrasar la creación hasta que termine engine->load():

// main.cpp
QQmlApplicationEngine *engine = new QQmlApplicationEngine();
engine->load(QUrl("qrc:/main.qml"));

// NOW create system tray (after QML loaded)
SystemTray *tray = new SystemTray(&app);

Resultado: arranque limpio, sin avisos de widgets.

Arquitectura del sistema de compilación: dos sistemas a la vez

El proyecto mantiene dos sistemas de compilación en paralelo para dar flexibilidad:

Sistema CMake (principal)

Lo usan release.makefile y las compilaciones de paquetes:

# CMakeLists.txt
cmake_minimum_required(VERSION 3.16)
project(stremio)

set(CMAKE_CXX_STANDARD 14)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)

find_package(Qt5 REQUIRED COMPONENTS Core Gui Widgets Qml Quick WebEngine DBus)
find_package(PkgConfig REQUIRED)
pkg_check_modules(MPV REQUIRED mpv)
pkg_check_modules(OPENSSL REQUIRED openssl)

# Sources including CompatibleSingleApp
set(SOURCES
    main.cpp
    compatible_singleapp.cpp
    stremioprocess.cpp
    # ... other sources
)

# Headers for MOC
set(HEADERS
    mainapplication.h
    compatible_singleapp.h
    stremioprocess.h
    # ... other headers
)

add_executable(stremio ${SOURCES} ${HEADERS} resources.qrc)

target_link_libraries(stremio
    Qt5::Core Qt5::Gui Qt5::Widgets Qt5::Qml Qt5::Quick Qt5::WebEngine Qt5::DBus
    ${MPV_LIBRARIES}
    ${OPENSSL_LIBRARIES}
)

install(TARGETS stremio DESTINATION bin)

Comando de compilación:

QT_DEFAULT_MAJOR_VERSION=5 make -f release.makefile
# Result: 293KB optimized binary

Sistema qmake (heredado)

Se usa para compilaciones manuales y para desarrollo:

# stremio.pro
QT += core gui widgets qml quick webengine dbus
CONFIG += c++14

SOURCES += \
    main.cpp \
    compatible_singleapp.cpp \
    stremioprocess.cpp \
    # ... other sources

HEADERS += \
    mainapplication.h \
    compatible_singleapp.h \
    stremioprocess.h \
    # ... other headers

RESOURCES += resources.qrc

# System libraries
unix:!macx {
    CONFIG += link_pkgconfig
    PKGCONFIG += mpv openssl
}

target.path = /usr/bin
INSTALLS += target

Comando de compilación:

QT_SELECT=5 qmake
QT_SELECT=5 make
# Result: 278KB optimized binary

Los dos sistemas producen binarios que funcionan con un 100% de bibliotecas del sistema.

Empaquetado en Debian: como es debido

Estructura del paquete

stremio (4.4.169+dfsg-1):

debian/
├── changelog                    # Version history with ITP closure
├── control                      # Dependencies and package metadata
├── copyright                    # GPL-3.0+ licensing details
├── rules                        # Build instructions (dh-based)
├── patches/                     # Quilt patches for system integration
│   ├── 0001-Fix-server.js-path-for-FHS-compliance.patch
│   ├── 0002-disable-server-download.patch
│   ├── 0004-minimal-qthelper-integration.patch
│   ├── 0005-cmake-system-libraries-v4.4.169.patch
│   ├── 0007-add-qtwebengine-initialize-fix.patch
│   ├── 0008-add-compatible-singleapp-implementation.patch
│   ├── 0009-remove-system-singleapplication-add-compatible.patch
│   ├── 0010-fix-qmake-install-paths.patch
│   └── 0011-fix-qprocess-environment-for-server-launch.patch
├── stremio.desktop              # Desktop integration
├── stremio.install              # File installation rules
├── watch                        # Upstream version monitoring
└── source/
    └── format                   # 3.0 (quilt) format

Secciones clave de debian/control:

Source: stremio
Section: video
Priority: optional
Maintainer: Juan Manuel Méndez Rey <vejeta@gmail.com>
Build-Depends:
    debhelper-compat (= 13),
    cmake,
    qtbase5-dev,
    qt5-qmake,
    qt5-qmake-bin,
    qtdeclarative5-dev,
    qtwebengine5-dev,
    qttools5-dev,
    qml-module-qtwebchannel,
    qml-module-qt-labs-platform,
    qml-module-qtwebengine,
    qml-module-qtquick-dialogs,
    qml-module-qtquick-controls,
    qml-module-qt-labs-settings,
    qml-module-qt-labs-folderlistmodel,
    libmpv-dev,
    libssl-dev,
    nodejs,
    npm,
    pkg-kde-tools
Standards-Version: 4.6.2
Homepage: https://www.stremio.com/
Vcs-Git: https://salsa.debian.org/mendezr/stremio.git
Vcs-Browser: https://salsa.debian.org/mendezr/stremio

Package: stremio
Architecture: amd64
Depends: ${shlibs:Depends}, ${misc:Depends},
         nodejs,
         mpv,
         librsvg2-2,
         qml-module-qtwebengine,
         qml-module-qtwebchannel,
         qml-module-qt-labs-platform,
         qml-module-qtquick-controls,
         qml-module-qtquick-dialogs,
         qml-module-qt-labs-settings,
         qml-module-qt-labs-folderlistmodel,
         qtbase5-dev-tools
Description: Modern media center for streaming video content
 Stremio is a video streaming application that aggregates content from
 various sources. It features a modern Qt5/QML interface with support
 for add-ons, local playback via MPV, and integration with streaming
 services.
 .
 This package provides the desktop client with GPL-licensed components.

Proceso de compilación:

# Development build
QT_DEFAULT_MAJOR_VERSION=5 dpkg-buildpackage -us -uc

# Package build with signature
QT_DEFAULT_MAJOR_VERSION=5 dpkg-buildpackage -sa

# Clean environment build
sudo pbuilder build ../stremio_4.4.169+dfsg-1.dsc

Paquete stremio-server (versionado independiente)

Decisión crítica: el servidor usa un número de versión independiente que sigue a su upstream:

Source: stremio-server
Section: non-free/video
Version: 4.20.12-1

Package: stremio-server
Architecture: all
Depends: ${misc:Depends}, nodejs (>= 12)
Description: BitTorrent streaming server for Stremio (proprietary)
 Proprietary streaming server component providing BitTorrent support,
 HLS transcoding, and casting functionality for Stremio.
 .
 Version 4.20.12 corresponds to upstream server.js release.

¿Por qué un versionado independiente?

  • El servidor tiene un ciclo de publicaciones distinto al del cliente
  • El server.js de upstream se actualiza por su cuenta (v4.20.x)
  • El cliente se actualiza por su cuenta (v4.4.x)
  • Sigue la práctica del sector: VS Code, Docker Desktop, Firefox ESR

debian/copyright documenta el fuente:

Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Upstream-Name: stremio-server
Source: https://dl.strem.io/server/v4.20.12/desktop/server.js
Comment: Pre-downloaded server.js included in source package to comply
 with Debian Policy prohibiting network access during builds.

Más allá de Debian: la contribución a Wolfi

Mientras trabajaba en el empaquetado para Debian, también contribuí paquetes de Stremio a Wolfi Linux, la distribución centrada en la seguridad que usa Chainguard. Esto incluyó:

  • Ficheros de compilación de Melange: formato de paquete nativo de la nube
  • Endurecimiento de seguridad: ASLR, protección de pila, RELRO
  • Cumplimiento de licencias OSI: solo componentes GPL (sin el servidor propietario, el mismo server.js que separamos en un paquete non-free para Debian)
  • Compilaciones reproducibles: entorno de compilación hermético

Ejemplo de configuración de Melange:

package:
  name: stremio
  version: 4.4.169
  epoch: 0
  description: Modern media center for video streaming
  license: GPL-3.0-or-later

environment:
  contents:
    packages:
      - qt5-qtbase-dev
      - qt5-qtdeclarative-dev
      - qt5-qtwebengine-dev
      - mpv-dev
      - openssl-dev

pipeline:
  - uses: cmake/configure
  - uses: cmake/build
  - uses: cmake/install

subpackages:
  - name: stremio-doc
    description: Documentation for stremio

Usé este trabajo en paralelo como ejercicio para aprender cómo hacen un empaquetado correcto las distintas distribuciones en diferentes ecosistemas.

Pull Request:
https://github.com/wolfi-dev/os/pull/69098
GitHub Gists con ejemplos de uso:
https://gist.github.com/vejeta/859f100ef74b87eadf7f7541ead2a2b1

El reto de la distribución: un repositorio APT apoyado en GitHub

Entrar en Debian de forma oficial lleva tiempo: meses o años de revisión, pruebas y refinamiento. Mientras tanto, los usuarios necesitaban una solución ya. Los enfoques tradicionales, como alojar los paquetes en un servidor personal, crearían problemas de ancho de banda y de mantenimiento.

La solución: alojar un repositorio APT moderno usando la infraestructura de GitHub.

Visión general de la arquitectura

┌─────────────────────────────────────────────────────────┐
│              Canonical Sources (Salsa)                  │
│  https://salsa.debian.org/mendezr/stremio               │
│  https://salsa.debian.org/mendezr/stremio-server        │
└────────────────────┬────────────────────────────────────┘
                     │
                     │ Instant Webhook + Weekly Cron
                     ▼
┌─────────────────────────────────────────────────────────┐
│          GitHub Repository (Build System)               │
│      https://github.com/vejeta/stremio-debian           │
│                                                          │
│  • stremio-client/ (git submodule → Salsa)             │
│  • stremio-server/ (git submodule → Salsa)             │
│  • .github/workflows/                                   │
│      - build-and-release.yml                            │
│      - deploy-repository.yml                            │
│      - sync-from-salsa.yml                              │
│  • repository-scripts/                                  │
│      - generate-apt-repo.sh                             │
│      - sign-repository.sh                               │
└────────────────────┬────────────────────────────────────┘
                     │
       ┌─────────────┴─────────────┐
       │                           │
       ▼                           ▼
┌──────────────┐          ┌────────────────┐
│GitHub Releases│         │ GitHub Pages   │
│              │          │                │
│ Binary .debs │          │ APT Repository │
│ Source files │          │ Signed metadata│
│ Build logs   │          │ Global CDN     │
└──────────────┘          └────────────────┘
                                   │
                                   ▼
                          ┌────────────────┐
                          │ Custom Domain  │
                          │ debian.vejeta  │
                          │     .com       │
                          └────────────────┘

Estrategia multidistribución: compilaciones en matriz

El descubrimiento clave: los paquetes compilados en una publicación de Debian no funcionan en las demás por las dependencias de ABI.

Ejemplo del problema:

# Package built on Debian Bookworm:
$ dpkg -I stremio_4.4.169+dfsg-1_amd64.deb | grep Depends
Depends: qtdeclarative-abi-5-15-8

# But Debian Sid/Kali have:
$ apt-cache show qtdeclarative5-dev | grep Provides
Provides: qtdeclarative-abi-5-15-15

# Result: Installation fails on Sid/Kali

Solución: compilar los paquetes en contenedores nativos de cada distribución:

# .github/workflows/build-and-release.yml
jobs:
  build-stremio-client:
    name: Build stremio (main/free) - ${{ matrix.distro }}
    runs-on: ubuntu-latest
    strategy:
      matrix:
        distro: [trixie, bookworm, sid, noble]
        include:
          - distro: trixie
            suite: stable
            os_type: debian
          - distro: bookworm
            suite: oldstable
            os_type: debian
          - distro: sid
            suite: unstable
            os_type: debian
          - distro: noble
            suite: lts
            os_type: ubuntu
    container:
      image: ${{ matrix.os_type }}:${{ matrix.distro }}
      options: --privileged

    steps:
      - name: Install build dependencies
        run: |
          apt-get update
          apt-get install -y \
            git git-buildpackage pristine-tar \
            debhelper-compat cmake \
            qtbase5-dev qt5-qmake qt5-qmake-bin \
            qtdeclarative5-dev qtwebengine5-dev qttools5-dev \
            qml-module-qtwebchannel qml-module-qt-labs-platform \
            qml-module-qtwebengine qml-module-qtquick-dialogs \
            qml-module-qtquick-controls qml-module-qt-labs-settings \
            qml-module-qt-labs-folderlistmodel \
            libmpv-dev libssl-dev nodejs npm pkg-kde-tools \
            devscripts lintian dpkg-dev fakeroot librsvg2-bin

      - name: Checkout repository with submodules
        uses: actions/checkout@v4
        with:
          fetch-depth: 0
          submodules: recursive

      - name: Configure git for gbp
        run: |
          git config --global user.email "vejeta@gmail.com"
          git config --global user.name "Juan Manuel Méndez Rey"
          git config --global --add safe.directory '*'

      - name: Create upstream tarball
        working-directory: stremio-client
        run: |
          VERSION=$(dpkg-parsechangelog -S Version | cut -d- -f1)

          # Try pristine-tar first
          if git rev-parse --verify pristine-tar >/dev/null 2>&1; then
            pristine-tar checkout ../stremio_${VERSION}.orig.tar.xz 2>/dev/null || \
            pristine-tar checkout ../stremio_${VERSION}.orig.tar.gz 2>/dev/null
          fi

          # Fallback to upstream tag
          if [ ! -f ../stremio_${VERSION}.orig.tar.* ]; then
            UPSTREAM_TAG=$(git tag -l "upstream/*" | grep -E "${VERSION%+*}" | tail -1)
            git archive --format=tar --prefix=stremio-${VERSION%+*}/ $UPSTREAM_TAG | \
              xz > ../stremio_${VERSION}.orig.tar.xz
          fi

      - name: Build packages (source + binary)
        working-directory: stremio-client
        run: |
          QT_DEFAULT_MAJOR_VERSION=5 dpkg-buildpackage -us -uc -sa

      - name: Run lintian checks
        continue-on-error: true
        run: |
          lintian --info --display-info --pedantic stremio-client/../*.deb || true

      - name: Smoke test package (Ubuntu only)
        if: matrix.os_type == 'ubuntu'
        continue-on-error: true
        run: |
          echo "=== Ubuntu Package Smoke Test ==="
          apt install -y ./stremio-client/../*.deb || true
          which stremio && echo "✓ Binary found" || echo "✗ Binary not found"
          ldd /usr/bin/stremio | grep -E "(libQt5|libmpv|libcrypto)" || true
          export QT_QPA_PLATFORM=offscreen
          export QTWEBENGINE_DISABLE_SANDBOX=1
          timeout 10s stremio 2>&1 || echo "✓ GUI test completed"

      - name: Collect build artifacts
        run: |
          mkdir -p artifacts/stremio-client-${{ matrix.distro }}

          # Rename .deb with distro suffix
          for deb in stremio-client/../*.deb; do
            if [ -f "$deb" ]; then
              filename=$(basename "$deb")
              newname="${filename%.deb}-${{ matrix.distro }}.deb"
              mv "$deb" "artifacts/stremio-client-${{ matrix.distro }}/$newname"
            fi
          done

          # Move other files
          mv stremio-client/../*.dsc artifacts/stremio-client-${{ matrix.distro }}/ 2>/dev/null || true
          mv stremio-client/../*.tar.* artifacts/stremio-client-${{ matrix.distro }}/ 2>/dev/null || true
          mv stremio-client/../*.buildinfo artifacts/stremio-client-${{ matrix.distro }}/ 2>/dev/null || true
          mv stremio-client/../*.changes artifacts/stremio-client-${{ matrix.distro }}/ 2>/dev/null || true

      - name: Upload build artifacts
        uses: actions/upload-artifact@v4
        with:
          name: stremio-client-packages-${{ matrix.distro }}
          path: artifacts/stremio-client-${{ matrix.distro }}/*.deb
          retention-days: 30

Resultado: cada distribución recibe paquetes con las dependencias nativas correctas:

  • debian:trixie → qtdeclarative-abi-5-15-15
  • debian:bookworm → qtdeclarable-abi-5-15-8
  • debian:sid → qtdeclarable-abi-5-15-17
  • ubuntu:noble → dependencias de Qt5 específicas de Ubuntu

Generación del repositorio APT

Script: repository-scripts/generate-apt-repo.sh

#!/bin/bash
set -e

PACKAGE_DIR="$1"    # packages/trixie/main
REPO_DIR="$2"       # debian-repo
SUITE="$3"          # trixie
COMPONENT="$4"      # main

echo "Generating APT repository for $SUITE/$COMPONENT"

# Create directory structure
mkdir -p "$REPO_DIR/dists/$SUITE/$COMPONENT/binary-amd64"
mkdir -p "$REPO_DIR/pool/$SUITE/$COMPONENT"

# Copy packages to pool
if [ -d "$PACKAGE_DIR" ] && [ "$(ls -A $PACKAGE_DIR/*.deb 2>/dev/null)" ]; then
    cp "$PACKAGE_DIR"/*.deb "$REPO_DIR/pool/$SUITE/$COMPONENT/"
fi

# Generate Packages file
cd "$REPO_DIR"
dpkg-scanpackages --arch amd64 "pool/$SUITE/$COMPONENT" /dev/null > \
    "dists/$SUITE/$COMPONENT/binary-amd64/Packages"

# Compress Packages file
gzip -9 -k "dists/$SUITE/$COMPONENT/binary-amd64/Packages"

echo "✓ Repository generated for $SUITE/$COMPONENT"

Estructura del repositorio APT:

debian-repo/
├── dists/
│   ├── trixie/
│   │   ├── main/
│   │   │   └── binary-amd64/
│   │   │       ├── Packages
│   │   │       └── Packages.gz
│   │   ├── non-free/
│   │   │   └── binary-amd64/
│   │   │       ├── Packages
│   │   │       └── Packages.gz
│   │   ├── Release
│   │   └── InRelease (GPG signed)
│   ├── bookworm/
│   │   └── [same structure]
│   ├── sid/
│   │   └── [same structure]
│   └── noble/
│       └── [same structure]
├── pool/
│   ├── trixie/
│   │   ├── main/
│   │   │   └── stremio_4.4.169+dfsg-1_amd64.deb
│   │   └── non-free/
│   │       └── stremio-server_4.20.12-1_all.deb
│   ├── bookworm/
│   │   └── [same structure]
│   ├── sid/
│   │   └── [same structure]
│   └── noble/
│       └── [same structure]
└── key.gpg

Generación del fichero Release con sumas de verificación

Fragmento del workflow (.github/workflows/deploy-repository.yml):

- name: Update Release files for all distributions
  run: |
    cd debian-repo

    update_release() {
      local SUITE=$1

      cat > dists/$SUITE/Release << EOF
    Origin: Stremio Debian Repository
    Label: Stremio
    Suite: $SUITE
    Codename: $SUITE
    Components: main non-free
    Architectures: amd64
    Description: Unofficial Debian packages for Stremio media center ($SUITE)
    Date: $(date -R -u)
    EOF

      # Add MD5Sum checksums
      echo "MD5Sum:" >> dists/$SUITE/Release
      find dists/$SUITE -type f ! -name "Release*" | while read file; do
          relative_path="${file#dists/$SUITE/}"
          md5=$(md5sum "$file" | awk '{print $1}')
          size=$(stat -c%s "$file")
          printf " %s %8d %s\n" "$md5" "$size" "$relative_path" >> dists/$SUITE/Release
      done

      # Add SHA1 checksums
      echo "SHA1:" >> dists/$SUITE/Release
      find dists/$SUITE -type f ! -name "Release*" | while read file; do
          relative_path="${file#dists/$SUITE/}"
          sha1=$(sha1sum "$file" | awk '{print $1}')
          size=$(stat -c%s "$file")
          printf " %s %8d %s\n" "$sha1" "$size" "$relative_path" >> dists/$SUITE/Release
      done

      # Add SHA256 checksums
      echo "SHA256:" >> dists/$SUITE/Release
      find dists/$SUITE -type f ! -name "Release*" | while read file; do
          relative_path="${file#dists/$SUITE/}"
          sha256=$(sha256sum "$file" | awk '{print $1}')
          size=$(stat -c%s "$file")
          printf " %s %8d %s\n" "$sha256" "$size" "$relative_path" >> dists/$SUITE/Release
      done
    }

    # Generate for all distributions
    update_release trixie
    update_release bookworm
    update_release sid
    update_release noble

Firmado GPG

Script: repository-scripts/sign-repository.sh

#!/bin/bash
set -e

REPO_DIR="$1"
SUITE="$2"
GPG_KEY_ID="$3"

cd "$REPO_DIR/dists/$SUITE"

# Clear sign Release file to create InRelease
gpg --default-key "$GPG_KEY_ID" --clearsign --output InRelease Release

# Detached signature for Release.gpg
gpg --default-key "$GPG_KEY_ID" --armor --detach-sign --output Release.gpg Release

echo "✓ Signed repository for $SUITE"

Despliegue en GitHub Pages

Workflow (simplificado):

- name: Setup Pages
  uses: actions/configure-pages@v4

- name: Upload artifact
  uses: actions/upload-pages-artifact@v3
  with:
    path: debian-repo

- name: Deploy to GitHub Pages
  uses: actions/deploy-pages@v4

Resultado: repositorio APT servido en https://debian.vejeta.com/ con:

  • ✅ CDN global (CloudFlare)
  • ✅ Cifrado HTTPS
  • ✅ Ancho de banda ilimitado
  • ✅ Cero costes de alojamiento
  • ✅ Disponibilidad de más del 99.9%

Lecciones importantes: buenas prácticas al desarrollar parches

Durante este proyecto cometí errores de eficiencia importantes al desarrollar los parches. Esto es lo que aprendí:

El problema de la ineficiencia

Lo que hice (más de 5 iteraciones rehaciendo parches):

  1. Modificaba los ficheros fuente directamente en el repositorio de trabajo
  2. Generaba los parches desde el estado modificado
  3. Los parches fallaban sobre un upstream limpio
  4. Repetía todo el proceso varias veces

Impacto: ~70% del tiempo perdido en el desarrollo de parches

El enfoque correcto

Flujo de trabajo eficiente para desarrollar parches:

# Step 1: Clean upstream baseline
git clone --branch v4.4.169 https://github.com/Stremio/stremio-shell.git /tmp/patch-test
cd /tmp/patch-test

# Step 2: Analyze dependencies BEFORE making changes
echo "=== Mapping file dependencies ==="
grep -r "#include" *.cpp *.h | grep -v "Qt\|std"
grep -r "class.*:" *.h
grep -r "Q_OBJECT" *.h

# Step 3: Make ONE fix at a time
vim main.cpp  # Add QtWebEngine::initialize()
git diff > /tmp/0007-qtwebengine-fix.patch

# Step 4: Test patch application
git checkout .
patch -p1 < /tmp/0007-qtwebengine-fix.patch
mkdir build && cd build && cmake .. && make

# Step 5: If successful, continue to next fix
# If failed, refine current patch before moving on

Plantilla de análisis antes de parchear

Antes de crear parches, completa SIEMPRE este análisis:

## Files to Modify
- [ ] main.cpp - QtWebEngine initialization
- [ ] mainapplication.h - class definitions
- [ ] CMakeLists.txt - build system
- [ ] compatible_singleapp.h/cpp - new custom implementation

## Dependency Chain
1. main.cpp includes → mainapplication.h
2. mainapplication.h includes → singleapplication.h (to be replaced)
3. CMakeLists.txt references → SingleApplication (to be removed)
4. Qt MOC processes → Q_OBJECT classes (check for conflicts)

## Build Test Plan
1. [ ] Clean cmake build
2. [ ] Dependency verification (ldd)
3. [ ] Runtime functionality test
4. [ ] Package build test (dpkg-buildpackage)

Validación antes de declarar «listo»

NUNCA des los parches por listos sin:

# MANDATORY validation workflow
mkdir /tmp/patch-validation
cd /tmp/patch-validation
git clone --branch v4.4.169 <upstream-url> .

# Apply ALL patches
export QUILT_PATCHES=debian/patches
quilt push -a || { echo "FAIL: Patch application"; exit 1; }

# Complete build test
mkdir build && cd build
cmake .. && make || { echo "FAIL: Build"; exit 1; }

# Package build test
cd .. && dpkg-buildpackage -us -uc || { echo "FAIL: Package"; exit 1; }

# Dependency check
ldd build/stremio | grep -E "(libQt5|libmpv|libcrypto)"

# ONLY NOW declare "patches ready"
echo "✅ Validated and ready for production"

Este flujo de trabajo evita el ciclo «listo → falla → a rehacer» que hace perder tiempo de desarrollo.

Validación en producción: pruebas completas

Validación en un entorno aislado

Montaje de la prueba:

# Create pristine environment
mkdir /tmp/stremio-patch-validation
cd /tmp/stremio-patch-validation
git clone --branch v4.4.169 https://github.com/Stremio/stremio-shell.git .
cp -r /path/to/debian .

# Apply all patches
export QUILT_PATCHES=debian/patches
quilt push -a
# Result: All 6 patches applied successfully

# Test CMake build
mkdir build && cd build
cmake .. -DQT_DEFAULT_MAJOR_VERSION=5
make -j$(nproc)
# Result: 293KB binary with 100% system libraries

# Test release.makefile
cd .. && QT_DEFAULT_MAJOR_VERSION=5 make -f release.makefile
# Result: Complete success including icon generation

# Verify dependencies
ldd build/stremio | head -5
# Output:
#   libQt5WebEngine.so.5 => /lib/x86_64-linux-gnu/libQt5WebEngine.so.5
#   libQt5DBus.so.5 => /lib/x86_64-linux-gnu/libQt5DBus.so.5
#   libcrypto.so.3 => /lib/x86_64-linux-gnu/libcrypto.so.3
#   libmpv.so.2 => /lib/x86_64-linux-gnu/libmpv.so.2

Resultados de la verificación:

  • ✅ El binario compila bien (293KB)
  • ✅ La GUI carga y se muestra
  • ✅ El comportamiento de instancia única funciona
  • ✅ El servidor de streaming arranca (el puerto 11470 responde)
  • ✅ Integración completa con las bibliotecas del sistema
  • ✅ Sin caídas ni problemas de hilos

Validación en tiempo de ejecución

Prueba completa de funcionalidad:

# Launch application
./build/stremio 2>&1 | tee /tmp/stremio-runtime.log

# Verify server startup (first 15 seconds)
timeout 15s ./build/stremio 2>&1 | grep -E "(server|streaming|port)"
# Output:
#   hls executables located -> { ffmpeg: '/usr/bin/ffmpeg', ffsplit: null }
#   Using app path -> /home/user/.stremio-server
#   Enabling casting...
#   EngineFS server started at http://127.0.0.1:11470

# Test server endpoint
curl -s http://127.0.0.1:11470 && echo "✓ Server responding"

# Test single-instance behavior
./build/stremio &
PID1=$!
sleep 2
./build/stremio   # Should detect first instance and exit
wait $PID1

Experiencia de usuario: instalación simplificada

Quería que otros usuarios de Debian pudieran instalar cuanto antes estos paquetes, construidos con los estándares más altos, mientras los desarrolladores de Debian siguen revisando el paquete. Mi solución fue crear un repositorio y, mediante GitHub Actions, descargar los fuentes de los paquetes desde salsa.debian.org, compilarlos de forma automática, hacer una publicación y ofrecer un repositorio de Debian montado con GitHub Pages, para que los usuarios de Debian tengan un 99% de disponibilidad para descargarlos.

El resultado final es una instalación de un solo comando para los usuarios:

Para Debian Trixie (13, la estable actual)

wget -qO - https://debian.vejeta.com/key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/stremio-debian.gpg
echo "deb [signed-by=/usr/share/keyrings/stremio-debian.gpg] https://debian.vejeta.com trixie main non-free" | sudo tee /etc/apt/sources.list.d/stremio.list
sudo apt update
sudo apt install stremio stremio-server

Para Debian Sid / Kali Linux

wget -qO - https://debian.vejeta.com/key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/stremio-debian.gpg
echo "deb [signed-by=/usr/share/keyrings/stremio-debian.gpg] https://debian.vejeta.com sid main non-free" | sudo tee /etc/apt/sources.list.d/stremio.list
sudo apt update
sudo apt install stremio stremio-server

Para Ubuntu 24.04 LTS (Noble), EXPERIMENTAL

wget -qO - https://debian.vejeta.com/key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/stremio-debian.gpg
echo "deb [signed-by=/usr/share/keyrings/stremio-debian.gpg] https://debian.vejeta.com noble main non-free" | sudo tee /etc/apt/sources.list.d/stremio.list
sudo apt update
sudo apt install stremio stremio-server

Nota: el soporte de Ubuntu es experimental, con compilaciones automáticas pero pruebas manuales limitadas. Se agradecen los comentarios de la comunidad.

Cerrando el círculo: actualizar la documentación

Con una solución funcionando ya desplegada, volví al punto donde empezó todo: la documentación. Envié un pull request completo para actualizar el fichero DEBIAN.md original que había contribuido años antes.

El PR añade:

  • ✅ Instalación desde el repositorio APT (el nuevo método recomendado)
  • ✅ Listas completas de dependencias
  • ✅ Prácticas de seguridad modernas (buena gestión de las claves GPG)
  • ✅ Soporte para varias distribuciones (Debian y derivadas)
  • ✅ Instrucciones de compilación mantenidas (se conservan para los desarrolladores)

Impacto en la comunidad

A las pocas horas de enviar el PR, comenté en más de 10 issues abiertos de GitHub donde los usuarios habían informado de problemas de instalación. La respuesta fue inmediata y positiva: por fin podían instalar Stremio sin dolores de cabeza con la compilación.

Resumen de los logros técnicos

Excelencia en el empaquetado

  • ✅ Cero dependencias incluidas: 100% bibliotecas del sistema de Debian
  • ✅ Cumplimiento del FHS: rutas de instalación correctas en /usr
  • ✅ Separación de licencias: cliente GPL (main) + servidor propietario (non-free)
  • ✅ Cumplimiento de la política: empaquetado limpio para lintian
  • ✅ Versionado independiente: cliente v4.4.169 + servidor v4.20.12

Soluciones técnicas

  • ✅ Arreglo de la inicialización de QtWebEngine: una sola línea evita todos los fallos de QML
  • ✅ CompatibleSingleApp: implementación propia de instancia única, segura con hilos
  • ✅ Entorno de QProcess: configuración correcta del entorno de Node.js para el servidor de streaming
  • ✅ Dos sistemas de compilación: CMake (293KB) y qmake (278KB), los dos funcionando
  • ✅ Integración con bibliotecas del sistema: MPV, Qt5, OpenSSL y todos los módulos QML

Infraestructura

  • ✅ Compilaciones multidistribución: Trixie, Bookworm, Sid y Noble (experimental)
  • ✅ CI/CD automatizado: GitHub Actions con estrategia de matriz
  • ✅ Repositorio APT: GitHub Pages con CDN global
  • ✅ Firmado GPG: paquetes y metadatos firmados criptográficamente
  • ✅ Cero costes de alojamiento: ancho de banda ilimitado vía GitHub
  • ✅ Estadísticas de descargas: analítica integrada vía GitHub Releases

Estadísticas de compilación

  • Tamaño del binario: 293KB optimizado (frente a 424KB con depuración)
  • Tiempo de compilación: ~10 minutos por distribución
  • Total de distribuciones: 4 (3 de Debian + 1 Ubuntu experimental)
  • Paquetes por publicación: 8 ficheros .deb (4 distribuciones × 2 paquetes)
  • Tamaño del repositorio: ~21 MB por publicación

Mirando al futuro

Objetivos inmediatos

Progreso del envío a Debian (ITP #943703):

  • [x] Paquetes fuente creados siguiendo la política de Debian
  • [x] Empaquetado limpio para lintian
  • [x] 100% bibliotecas del sistema
  • [x] Cumplimiento del FHS
  • [x] Fichero de copyright con el licenciamiento completo
  • [x] Ficheros watch para vigilar upstream
  • [x] Flujo de trabajo con git-buildpackage
  • [x] Paquetes alojados en Salsa
  • [x] Bug de ITP abierto
  • [x] Revisión preliminar de un desarrollador de Debian
  • [ ] Patrocinio conseguido
  • [ ] Subida a la cola NEW de Debian

Calendario: envío previsto para el primer trimestre de 2025

Aplicaciones profesionales

Este trabajo apoya de forma directa mi objetivo de ser mantenedor oficial de paquetes de Debian. También puede servir de guía para que otros ganen experiencia en:

  • Experiencia en empaquetado: flujos modernos de empaquetado en Debian con aplicaciones complejas
  • Soltura en DevOps: diseño de tuberías CI/CD y automatización con GitHub Actions
  • Capacidad de resolver problemas: depuración a fondo (QtWebEngine, hilos, problemas de entorno)
  • Participación en la comunidad: resolver problemas reales de usuarios a gran escala
  • Diseño de infraestructura: sistemas de distribución escalables y rentables
  • Documentación: redacción técnica completa para públicos diversos

Evolución futura

La arquitectura funcionó tan bien que estoy pensando en replicarla para otros proyectos de empaquetado. El patrón de usar la infraestructura de GitHub para alojar un repositorio APT puede venir bien a muchos proyectos que luchan con problemas de distribución.

Posibles aplicaciones:

  • Repositorio personal para paquetes experimentales de Debian
  • Otras aplicaciones multimedia que requieran montajes complejos de Qt5/WebEngine
  • Empaquetado entre distribuciones (Debian + Ubuntu + derivadas)

Principios clave reforzados

Este viaje reforzó varios principios fundamentales:

1. La documentación es infraestructura

Una buena documentación no es solo texto: es la base que permite que los usuarios la adopten y que la comunidad crezca. El fichero DEBIAN.md original acabó siendo una solución completa de empaquetado y distribución.

2. Empaquetar es diseñar el producto

Cómo instalan y mantienen el software los usuarios es parte de la experiencia de usuario. Un mal empaquetado crea fricción; uno bueno la elimina. La diferencia entre:

  • ❌ «Descarga, descomprime, instala 15 dependencias, compila y copia los ficheros a mano»
  • ✅ «apt install stremio»

3. La infraestructura moderna permite escalar

Aprovechando la infraestructura de GitHub (Actions, Pages, Releases), un solo desarrollador puede ofrecer una infraestructura de distribución de nivel empresarial sin ninguna carga operativa. Eso democratiza la distribución de software.

4. Los estándares hacen posibles los ecosistemas

Seguir los estándares de empaquetado de Debian hizo que los mismos paquetes funcionen en varias distribuciones (Debian, Ubuntu, Kali) y puedan integrarse con el archivo oficial de Debian.

5. Entender la técnica a fondo merece la pena

Los arreglos críticos (inicialización de QtWebEngine, compatibilidad de hilos, variables de entorno) exigían entender a fondo:

  • El orden de inicialización de Qt5
  • El modelo de hilos del motor QML
  • La herencia del entorno en QProcess
  • Los requisitos del runtime de Node.js

Un conocimiento superficial no habría resuelto estos problemas.

6. Probar bien evita rehacer el trabajo

Las lecciones aprendidas al desarrollar los parches (70% del tiempo perdido en rehacerlos) demuestran que invertir en validar por adelantado evita mucho desperdicio después. Prueba contra un upstream limpio pronto y a menudo.

7. El versionado independiente respeta la realidad

Usar números de versión independientes para stremio (4.4.169) y stremio-server (4.20.12) sigue la práctica del sector y representa con precisión el desarrollo de upstream. Un versionado de conveniencia crea confusión.

Agradecimientos

  • Equipo de Stremio: por crear una aplicación de centro multimedia excelente
  • Comunidad de Debian: por los estándares de empaquetado y la infraestructura (Salsa)
  • GitHub: por el alojamiento gratuito, el CI/CD y el ancho de banda ilimitado
  • Proyecto Qt: por un framework multiplataforma excelente
  • Desarrolladores de Debian (Arturo): por la revisión preliminar y la orientación en el ITP #943703

Recursos técnicos

Repositorios del fuente

Proyectos de upstream

Estadísticas de distribución

  • Ancho de banda del repositorio: ilimitado (CDN de GitHub)
  • Total de descargas: se registra vía la API de GitHub Releases
  • Disponibilidad: más del 99.9% (SLA de GitHub)
  • Tasa de compilaciones correctas: 100% (tras aplicar los arreglos)

Conclusión

Lo que empezó como una sencilla contribución a la documentación se convirtió en una solución completa de empaquetado y distribución. Combinando los principios tradicionales del empaquetado en Debian con una infraestructura CI/CD moderna es posible ofrecer una distribución de software de nivel profesional que escala a nivel global.

El camino desde «¿cómo instalo esto?» hasta «apt install stremio» es más que progreso técnico: se trata de quitar fricción entre un software estupendo y la gente que quiere usarlo.

A veces las mejores soluciones cierran el círculo. Años después de contribuir la documentación de instalación, he vuelto para asegurarme de que esa documentación describe un proceso que de verdad funciona de forma fiable para todo el mundo.

Los retos técnicos (inicialización de QtWebEngine, compatibilidad de hilos, variables de entorno) exigieron resolver problemas a fondo y depurar de forma sistemática. Los retos de infraestructura (compilaciones multidistribución, alojamiento del repositorio APT, automatización CI/CD) exigieron prácticas DevOps modernas y pensar en clave de nube.

Pero al final, este proyecto va de facilitar las cosas a los usuarios. Cada decisión técnica, cada parche y cada optimización del flujo de trabajo sirve al objetivo de que Stremio sea accesible para los usuarios de Debian y de Ubuntu mediante un proceso de instalación sencillo y fiable.

Parte de la contribución en curso para ser mantenedor de paquetes de Debian

Si este artículo te ha resultado útil, considera:

Última actualización: 30 de octubre de 2025

Apéndice: referencia completa de comandos

Compilar desde el fuente (Debian/Ubuntu)

# Install build dependencies
sudo apt install \
    git git-buildpackage pristine-tar \
    debhelper-compat cmake \
    qtbase5-dev qt5-qmake qt5-qmake-bin \
    qtdeclarative5-dev qtwebengine5-dev qttools5-dev \
    qml-module-qtwebchannel qml-module-qt-labs-platform \
    qml-module-qtwebengine qml-module-qtquick-dialogs \
    qml-module-qtquick-controls qml-module-qt-labs-settings \
    qml-module-qt-labs-folderlistmodel \
    libmpv-dev libssl-dev nodejs npm pkg-kde-tools \
    devscripts lintian dpkg-dev fakeroot librsvg2-bin

# Clone repository
git clone --recursive https://salsa.debian.org/mendezr/stremio.git
cd stremio

# Build with CMake
mkdir build && cd build
QT_DEFAULT_MAJOR_VERSION=5 cmake ..
make -j$(nproc)

# Or build with qmake
QT_SELECT=5 qmake
QT_SELECT=5 make -j$(nproc)

# Or build package
QT_DEFAULT_MAJOR_VERSION=5 dpkg-buildpackage -us -uc

Probar la instalación del paquete

# Install package
sudo dpkg -i ../stremio_*.deb

# Fix dependencies if needed
sudo apt install -f

# Test binary
stremio --version
which stremio

# Check dependencies
ldd /usr/bin/stremio | grep -E "(libQt5|libmpv|libcrypto)"

# Run application
stremio

Gestión del repositorio

# Add GPG key
wget -qO - https://debian.vejeta.com/key.gpg | \
    sudo gpg --dearmor -o /usr/share/keyrings/stremio-debian.gpg

# Add repository (choose your distribution)
echo "deb [signed-by=/usr/share/keyrings/stremio-debian.gpg] https://debian.vejeta.com trixie main non-free" | \
    sudo tee /etc/apt/sources.list.d/stremio.list

# Update and install
sudo apt update
sudo apt install stremio stremio-server

# Verify installation
dpkg -L stremio
systemctl --user status stremio-server  # If systemd service installed

Depurar problemas en tiempo de ejecución

# Run with debug output
QT_DEBUG_PLUGINS=1 stremio

# Run in headless mode (for testing)
QT_QPA_PLATFORM=offscreen stremio

# Disable WebEngine sandbox (for containers)
QTWEBENGINE_DISABLE_SANDBOX=1 stremio

# Check server process
ps aux | grep server.js
lsof -i :11470

# Manual server test
/usr/bin/node /usr/share/stremio/server.js

# Test with gdb
gdb --args stremio
(gdb) run
(gdb) bt  # If crash occurs

Fin del artículo

Profundidad técnica: detalles de implementación de nivel de producción
Público objetivo: desarrolladores avanzados, administradores de sistemas y mantenedores de Debian

Comentar en Mastodon

Etiquetas

  • #debian
  • #linux
  • #stremio
  • #wolfi