¿Te ha pasado que tramitas una tarjeta “sin anualidad y con cashback jugoso”, pero de repente tu saldo no cuadra? 🤔 Bienvenido al club de los débitos silenciosos.

Mientras las apps nos deslumbran con colores pastel y trámites en 3 minutos, detrás de escena algunas aplican patrones oscuros (dark patterns) para colar seguros, coberturas y membresías automáticas (como el famoso Plata Protege o Plata+ en Plata Card, o las asistencias “de cortesía” de la banca tradicional) 💸👻.

🕵️‍♂️ La trampa maestra: ¿Por qué tu celular nunca vibra?

Seguro piensas: “Si me cobraran algo raro, me llegaría una notificación push al instante”. Falso. ❌

• 🛒 Cuando compras en el súper: La transacción viaja por Visa o Mastercard y la app te manda un aviso en milisegundos.
• 📋 Cuando te cobran un seguro o comisión: Es un asiento contable interno del propio banco. No pasa por la red de pagos externa, así que no detona alertas en tu teléfono.
• 📄 El truco legal: Por ley, solo están obligados a plasmarlo en tu estado de cuenta en PDF. Si eres de los que nunca descarga el PDF mensual… felicidades, llevas meses pagando la fiesta del banco sin enterarte 🥂.

🗓️ El Hack definitivo: Cómo estirar tus compras hasta 50+ días sin pagar intereses 🧠💡

Si vas a usar tarjetas de crédito, que el financiamiento trabaje para ti, no al revés. La matemática de calendario es simple:

• 🔴 Comprar el día de corte (o 1 día antes): Pésima idea. Entra en el corte inmediato y tienes apenas 20 días para liquidar.
• 🟢 Comprar el día posterior al corte (Corte + 1): ¡Modo genio activado! 🚀 Tu compra no entra en el ciclo actual, sino en el siguiente. Ganas los 30 días del nuevo ciclo + los 20 días de gracia. ¡Hasta 50 o 55 días de financiamiento libre de intereses!

💻 Nuestra solución: Un Auditor Forense con interfaz Cyberpunk en Python 🦾👾

Para no perder tiempo abriendo PDFs aburridos ni arriesgar contraseñas bancarias en apps sospechosas, armamos una herramienta de escritorio local en Python con estética retro neón y motor dual:

┌─────────────────────────────────────────────────────────┐
│     NEO-FINANCE // AUDITOR FORENSE & OPTIMIZADOR        │
│       Arrastra y suelta tus PDFs (con o sin RFC)       │
└────────────────────────────┬────────────────────────────┘
                             │
            ┌────────────────┴────────────────┐
            ▼                                 ▼
   🤖 IA Local (Ollama)              ⚡ Motor Mecánico
   Qwen 2.5 (14B / 7B)              Expresiones Regulares
   Razonamiento semántico           Cero consumo de CPU/GPU

¿Qué hace este script? 🛠️

1. 📂 Arrastrar y soltar (Drag & Drop): Arrastras de golpe los PDFs de Banorte, Santander, Citibanamex, Nu, Stori o Plata Card directo al programa.
2. 🔓 Desencriptado inteligente: Si el banco le metió candado con tu RFC, la terminal abre un portal retro seguro, lo descifra en memoria y recuerda la clave para el lote.
3. 🎯 Semáforo diario de tarjetas: Te dice exactamente cuál tarjeta te da más días libres de pago hoy (marcando en neón cian el plástico ganador y en rojo alerta las que están por cortar).
4. 🚨 Visor forense de cargos fantasma: Escanea renglón por renglón y separa las compras reales de cobros indebidos (anualidades no avisadas, seguros y membresías), dejando fuera los intereses habituales.
5. 🌐 100% privado y offline: Tus datos no tocan ningún servidor externo; todo se procesa en tu propia máquina.

🛡️ Checklist de supervivencia financiera (¡Aplícalo hoy!)

• [ ] Entra a tu app bancaria y apaga cualquier interruptor de asistencia vial, seguro de vida o protección de saldo.
• [ ] Descarga religiosamente tus estados de cuenta cada mes y busca la palabra “Comisiones”.
• [ ] Si ves cobros no autorizados, mete aclaración ante la UNE del banco: por ley tienes hasta 90 días naturales para exigir tu reembolso completo.
• [ ] Programa recordatorios en tu calendario para comprar solo a partir de tu Corte + 1.

¿Terminaste de grabar un tutorial técnico de más de una hora y te da pereza abrir Kdenlive o DaVinci Resolve para sacar clips? 😫✂️

Editar clips verticales manualmente para YouTube Shorts o TikTok consume horas de trabajo repetitivo: buscar momentos interesantes, recortar silencios, reencuadrar a formato vertical 9:16, desenfocar el fondo y subtitular palabra por palabra. Las herramientas SaaS en la nube como OpusClip cobran suscripciones mensuales recurrentes y suben tus grabaciones privadas a servidores externos. 💸🔒

La alternativa definitiva es montar tu propio pipeline automatizado de código abierto que corre al 100% en local. Con un solo script en Python, el sistema:

1. Detecta si tu grabación se dividió en dos partes y las une sin pérdida de calidad.
2. Analiza los canales de audio y aísla la pista limpia de tu micrófono (pista 2 de OBS).
3. Elimina pausas muertas con auto-editor.
4. Transcribe todo el audio con faster-whisper.
5. Envía la transcripción completa a qwen2.5:14b vía Ollama para extraer de 10 a 15 ganchos virales en JSON estricto.
6. Renderiza en lote los videos en formato vertical (9:16), con fondo desenfocado, título superior, subtítulos amarillos y metadatos incrustados.

📦 Requisitos previos en el sistema

Antes de ejecutar el script en tu distribución Linux, asegúrate de tener las dependencias listas:

Bash

# Herramientas base y modelos
sudo pacman -S ffmpeg   # En CachyOS / Arch (o apt install ffmpeg en Ubuntu/Debian)
pip install faster-whisper auto-editor

# Descarga del modelo en Ollama
ollama pull qwen2.5:14b

💻 El Código Completo (pipeline_ia_shorts.py)

Guarda este script en la carpeta donde tengas tus grabaciones (video.mp4 o video2.mp4):

Python

#!/usr/bin/env python3
import json
import os
import re
import subprocess
import urllib.request
from faster_whisper import WhisperModel

# --- CONFIGURACIÓN ---
VIDEO_BASE = "video.mp4" if os.path.exists("video.mp4") else "1.mp4"
VIDEO_EXTRA = "video2.mp4" if os.path.exists("video2.mp4") else ("2.mp4" if os.path.exists("2.mp4") else None)
VIDEO_PREPARED = "unido.mp4"
VIDEO_CLEAN = "video_ALTERED.mp4"
SRT_OUTPUT = "video_ALTERED.srt"
OUT_DIR = "/home/julioc/Automatizaciones/shorts/global/tutoriales"
OLLAMA_MODEL = "qwen2.5:14b"
OLLAMA_URL = "http://localhost:11434/api/generate"

os.makedirs(OUT_DIR, exist_ok=True)

# 0. DETECCIÓN DE PISTAS DE AUDIO Y UNIÓN DE VIDEOS
print("=" * 60)
print("[0/4] Verificando pistas de audio y videos a unir...")
print("=" * 60)

def count_audio_streams(file_path):
    try:
        cmd = [
            "ffprobe", "-v", "error", "-select_streams", "a",
            "-show_entries", "stream=index", "-of", "csv=p=0", file_path
        ]
        out = subprocess.check_output(cmd).decode().strip()
        return len(out.splitlines()) if out else 0
    except Exception:
        return 1

num_audio = count_audio_streams(VIDEO_BASE)
audio_map = "0:a:1" if num_audio >= 2 else "0:a:0"
print(f"[*] Pistas de audio detectadas: {num_audio} -> Seleccionada: {audio_map} ({'Micrófono pista 2' if audio_map == '0:a:1' else 'Pista principal'})")

if not os.path.exists(VIDEO_PREPARED) and not os.path.exists(VIDEO_CLEAN):
    if VIDEO_EXTRA and os.path.exists(VIDEO_EXTRA):
        print(f"[*] Detectado video adicional: {VIDEO_EXTRA}. Uniendo archivos...")
        with open("lista_unir.txt", "w", encoding="utf-8") as f:
            f.write(f"file '{VIDEO_BASE}'\nfile '{VIDEO_EXTRA}'\n")
        
        cmd_concat = [
            "ffmpeg", "-y", "-f", "concat", "-safe", "0",
            "-i", "lista_unir.txt",
            "-map", "0:v:0", "-map", audio_map,
            "-c", "copy", VIDEO_PREPARED
        ]
        subprocess.run(cmd_concat, check=True)
        os.remove("lista_unir.txt")
    else:
        print(f"[*] Procesando solo {VIDEO_BASE} con audio {audio_map}...")
        cmd_extract = [
            "ffmpeg", "-y", "-i", VIDEO_BASE,
            "-map", "0:v:0", "-map", audio_map,
            "-c", "copy", VIDEO_PREPARED
        ]
        subprocess.run(cmd_extract, check=True)
else:
    print(f"[!] Reutilizando archivo preparado existente...")

# 1. CORTE DE SILENCIOS CON AUTO-EDITOR
print("\n" + "=" * 60)
print("[1/4] Cortando silencios (>5s) con auto-editor...")
print("=" * 60)

input_for_autoeditor = VIDEO_PREPARED if os.path.exists(VIDEO_PREPARED) else VIDEO_BASE
if not os.path.exists(VIDEO_CLEAN):
    cmd_autoeditor = [
        "auto-editor", input_for_autoeditor,
        "--edit", "audio:threshold=4%,mincut=5s",
        "-o", VIDEO_CLEAN
    ]
    subprocess.run(cmd_autoeditor, check=True)
else:
    print(f"[!] Archivo {VIDEO_CLEAN} ya existe, reutilizando...")

# 2. TRANSCRIPCIÓN CON FASTER-WHISPER
print("\n" + "=" * 60)
print("[2/4] Verificando / generando subtítulos...")
print("=" * 60)

srt_text_dump = []
if not os.path.exists(SRT_OUTPUT):
    whisper_model = WhisperModel("small", device="cpu", compute_type="int8")
    segments, _ = whisper_model.transcribe(VIDEO_CLEAN, language="es")

    srt_entries = []
    for idx, seg in enumerate(segments, 1):
        t_start = f"{int(seg.start//3600):02d}:{int((seg.start%3600)//60):02d}:{int(seg.start%60):02d},000"
        t_end = f"{int(seg.end//3600):02d}:{int((seg.end%3600)//60):02d}:{int(seg.end%60):02d},000"
        srt_entries.append(f"{idx}\n{t_start} --> {t_end}\n{seg.text.strip()}\n")
        
        clean_start = f"{int(seg.start//3600):02d}:{int((seg.start%3600)//60):02d}:{int(seg.start%60):02d}"
        srt_text_dump.append(f"[{clean_start}] {seg.text.strip()}")

    with open(SRT_OUTPUT, "w", encoding="utf-8") as f:
        f.write("\n".join(srt_entries))
else:
    print(f"[!] Usando {SRT_OUTPUT} existente...")
    with open(SRT_OUTPUT, "r", encoding="utf-8") as f:
        lines = f.readlines()
    for i, line in enumerate(lines):
        if "-->" in line and i + 1 < len(lines):
            t_raw = line.split("-->")[0].strip().split(",")[0]
            txt = lines[i+1].strip()
            if txt:
                srt_text_dump.append(f"[{t_raw}] {txt}")

# 3. EXTRACCIÓN MASIVA CON QWEN 2.5 (10 A 15 CLIPS)
print("\n" + "=" * 60)
print(f"[3/4] Extrayendo entre 10 y 15 momentos virales con {OLLAMA_MODEL}...")
print("=" * 60)

prompt_analysis = f"""Eres un editor profesional de contenido en formato vertical (Shorts/TikTok).
Analiza detalladamente toda la transcripción y extrae OBLIGATORIAMENTE entre 10 y 15 momentos clave.

INSTRUCCIONES CRÍTICAS:
1. Cuota obligatoria: Mínimo 10 clips, máximo 15 clips. NO entregues menos de 10.
2. Cada clip debe durar entre 30 y 75 segundos.
3. Cubre TODO el video: extrae clips del inicio, de la parte media y del final.
4. Formato de timestamps: "HH:MM:SS" (estricto).
5. Títulos: En MAYÚSCULAS, breves, sin dos puntos ni comillas.
6. Campo filename: alfanumérico con guiones bajos (ej. "01_TITULO", "02_TITULO").

Devuelve EXCLUSIVAMENTE el arreglo JSON:
[
  {{
    "start": "00:00:45",
    "end": "00:01:35",
    "filename": "01_TITULO_RESUMEN",
    "title": "TITULO EN MAYUSCULAS",
    "desc": "Descripcion corta para metadatos"
  }}
]

Transcripción:
{chr(10).join(srt_text_dump)}
"""

payload = {
    "model": OLLAMA_MODEL,
    "prompt": prompt_analysis,
    "stream": False,
    "format": "json",
    "options": {
        "num_ctx": 16384,
        "num_predict": 4096,
        "temperature": 0.2
    }
}

req = urllib.request.Request(
    OLLAMA_URL,
    data=json.dumps(payload).encode("utf-8"),
    headers={"Content-Type": "application/json"}
)

with urllib.request.urlopen(req) as resp:
    res_data = json.loads(resp.read().decode("utf-8"))
    raw_response = res_data.get("response", "[]").strip()

if raw_response.startswith("```"):
    raw_response = re.sub(r"^```(?:json)?\s*", "", raw_response)
    raw_response = re.sub(r"\s*```$", "", raw_response)

try:
    parsed = json.loads(raw_response)
    clips = parsed.get("clips", parsed) if isinstance(parsed, dict) else parsed
except Exception as err:
    print(f"[!] Error procesando JSON de Ollama: {err}")
    print("Respuesta recibida:\n", raw_response)
    exit(1)

print(f"[✓] La IA detectó con éxito {len(clips)} segmentos.")

# 4. RENDERIZADO VERTICAL CON FFMPEG
print("\n" + "=" * 60)
print(f"[4/4] Renderizando {len(clips)} shorts en {OUT_DIR}...")
print("=" * 60)

for idx, clip in enumerate(clips, 1):
    start = clip["start"]
    end = clip["end"]
    fname = re.sub(r'[^a-zA-Z0-9_-]', '_', clip["filename"])
    title = clip["title"].replace(":", "\\:").replace("'", "").replace("%", "%%")
    desc = clip.get("desc", title)
    out_file = os.path.join(OUT_DIR, f"{fname}.mp4")

    print(f"\n[>] Short {idx}/{len(clips)}: {clip['title']}")
    print(f"    {start} -> {end}")

    filter_complex = (
        "[0:v]split=2[bg][fg];"
        "[bg]scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920,avgblur=30[bg_b];"
        "[fg]scale=1080:-1[fg_s];"
        "[bg_b][fg_s]overlay=(W-w)/2:(H-h)/2,"
        f"drawtext=expansion=none:text='{title}':font='Liberation Sans\\:style=Bold':fontcolor=white:fontsize=38:bordercolor=black:borderw=4:shadowcolor=black@0.6:shadowx=2:shadowy=2:x=(w-text_w)/2:y=240,"
        f"subtitles='{SRT_OUTPUT}':force_style='PlayResX=1080,PlayResY=1920,FontSize=42,FontName=Liberation Sans,Bold=1,PrimaryColour=&H0000FFFF,OutlineColour=&H00000000,BackColour=&H80000000,BorderStyle=1,Outline=3,Shadow=2,Alignment=2,MarginV=180',"
        "setpts=PTS-STARTPTS[v]"
    )

    cmd_ffmpeg = [
        "ffmpeg", "-y",
        "-ss", start,
        "-to", end,
        "-copyts",
        "-i", VIDEO_CLEAN,
        "-filter_complex", filter_complex,
        "-map", "[v]",
        "-map", "0:a:0",
        "-af", "asetpts=PTS-STARTPTS",
        "-c:v", "libx264",
        "-preset", "veryfast",
        "-crf", "18",
        "-c:a", "aac",
        "-metadata", f"title={clip['title']}",
        "-metadata", f"description={desc}",
        "-metadata", "artist=Julio Cesar",
        "-metadata", "genre=Technology / Linux Tutorial",
        out_file
    ]
    subprocess.run(cmd_ffmpeg, check=True)

print("\n" + "=" * 60)
print(f"[✓] Proceso completado: se generaron {len(clips)} shorts.")
print(f"[✓] Ruta: {OUT_DIR}")
print("=" * 60)

🔍 Los 3 Trucos Técnicos que Hacen Funcionar este Script

1. Auto-detección con ffprobe: Grabar con OBS suele generar la pista 1 (escritorio/audio del juego) y la pista 2 (micrófono). La función count_audio_streams() analiza los metadatos y asegura que Whisper y los videos procesen la voz limpia.
2. Ventana de contexto de 16k y num_predict: 4096: Por defecto, Ollama utiliza ventanas reducidas que truncan la respuesta y provocan que solo se genere 1 clip. Ajustar estos dos parámetros permite al modelo leer transcripciones largas y devolver un archivo JSON con más de 10 elementos sin romperse.
3. Filtro FFmpeg 9:16 con escape seguro: Los dos puntos (:) y porcentajes (%) rompen la sintaxis de drawtext. El script sanitiza automáticamente los títulos para que ningún carácter especial interrumpa el renderizado.

Ejecuta el script directamente en tu terminal:

Bash

python3 pipeline_ia_shorts.py

Al terminar, tendrás hasta 15 videos verticales listos en tu carpeta con títulos llamativos, subtítulos integrados y metadatos completos para subir a YouTube Shorts y TikTok sin pagar suscripciones. 🐧🚀

Montar tu propio servidor Git con Gitea en Docker es una excelente opción por su ligereza y control total sobre tus repositorios. Sin embargo, hay un problema común: si olvidas tu contraseña de administrador y das clic en “¿Olvidaste tu contraseña?”, el correo nunca llega.

¿La razón? Por defecto, Gitea viene con el servicio de correo (SMTP) desactivado.

Aquí te muestro cómo listar tus usuarios, recuperar el acceso de inmediato desde la terminal y dejar configurado el correo para el futuro.

1. Lista los usuarios registrados y cambia la contraseña (Sin correo)

No necesitas esperar ningún email ni saberte el nombre exacto de memoria. Puedes consultar los usuarios y restablecer la clave usando el CLI de Gitea dentro de tu contenedor Docker:

Bash

# 1. Identifica el nombre de tu contenedor
sudo docker ps

# 2. Lista todos los usuarios registrados en tu instancia
sudo docker exec -it -u git gitea_server gitea admin user list

# 3. Cambia la contraseña del usuario deseado
sudo docker exec -it -u git gitea_server gitea admin user change-password --username tu_usuario --password "TuNuevaClave123"

¡Listo! Ya puedes iniciar sesión en tu panel web con la nueva contraseña.

2. Configura el envío de correos (SMTP) para que no vuelva a pasar

Para que los correos de recuperación, notificaciones y confirmaciones funcionen en automático, solo debes editar el archivo app.ini de Gitea:

1. Abre el archivo de configuración dentro del contenedor:Bashsudo docker exec -it gitea_server vi /data/gitea/conf/app.ini
2. Añade o edita los bloques [mailer] y [service]:

Ini, TOML

[mailer]
ENABLED        = true
FROM           = "Gitea" <tu_correo@dominio.com>
PROTOCOL       = smtps
SMTP_ADDR      = smtp.tudominio.com
SMTP_PORT      = 465
USER           = tu_correo@dominio.com
PASSWD         = tu_contraseña_o_token
FORCE_TRUST_SERVER_CERT = false

[service]
DISABLE_REGISTRATION_PASSWORD_RESET = false

3. Reinicia el contenedor para aplicar los cambios:Bashsudo docker restart gitea_server

💡 Tip Pro: ¿No recuerdas la contraseña de tu cuenta de correo?

Si utilizas clientes de correo de escritorio como Mozilla Thunderbird, puedes ver tus contraseñas guardadas en texto claro:

1. Ve a Ajustes $\rightarrow$ Privacidad y seguridad.
2. Entra a la sección Contraseñas guardadas…
3. Haz clic en Mostrar contraseñas.

Copia la clave asociada a tu servidor SMTP y pégala en tu app.ini. ¡Problema resuelto!

¿Notas que sigues a cientos de cuentas que ni siquiera interactúan contigo o que dejaron de seguirte? 🤔 Mantener tu lista de seguidos limpia es clave para mejorar tu ratio de interacción (engagement).

Sin embargo, a diferencia de otras redes sociales, los algoritmos de Instagram y Meta son extremadamente estrictos con la automatización. Si realizas demasiadas acciones seguidas, te arriesgas a un molesto bloqueo temporal (Action Blocked) ⛔.

Aquí tienes la guía definitiva para limpiar tu cuenta con herramientas seguras y los ajustes exactos que debes aplicar. 👇

🛠️ Las mejores extensiones para Chrome: Unfolks vs. Unfollow AI

La forma más práctica de auditar tus seguidos desde el navegador web es mediante extensiones basadas en Chromium (Chrome, Brave, Edge). Su gran ventaja: nunca tienes que compartir tu contraseña con aplicaciones externas.

🌟 1. Unfolks (La opción más recomendada)

Es la herramienta más transparente y segura para trabajar directamente sobre tu sesión abierta.

• ⏱️ Pausas inteligentes (Jitter): Te permite programar intervalos aleatorios de 15 a 35 segundos entre cada acción para simular comportamiento 100% humano.
• 🛡️ Lista blanca (Whitelist): Protege a tus amigos, creadores favoritos o familiares para no eliminarlos por error.
• 📊 Exportación de listas: Descarga tus datos en formato CSV o JSON antes de tocar cualquier botón.

⚡ 2. Unfollow AI

• Cuenta con una interfaz moderna y procesos rápidos en un par de clics.
• Su versión gratuita es algo más limitada para personalizar pausas avanzadas.

⚙️ Reglas de oro para evitar bloqueos y sanciones

Para que el algoritmo de Instagram nunca detecte tu actividad como spam, aplica siempre esta configuración:

• 🎯 Límite diario estricto: No dejes de seguir a más de 40 a 60 cuentas al día (si tu perfil es nuevo o tiene poco movimiento, quédate en 20 o 30).
• ⏳ Intervalos de tiempo: Configura pausas de entre 15 y 35 segundos entre cada cuenta.
• ☕ Divide las sesiones: Trabaja en dos tandas separadas (por ejemplo, 25 cuentas por la mañana y 25 por la tarde).
• 📋 Revisión previa: Revisa la lista generada antes de activar el borrado automático para marcar excepciones.

🔒 El truco 100% oficial: Descarga tus datos de Meta

Si prefieres no utilizar ninguna extensión externa, puedes obtener la lista exacta directo de la fuente:

1. 📲 Entra a Configuración > Centro de cuentas > Tu información y permisos.
2. 📥 Toca en Descargar tu información y elige únicamente la opción Seguidores y seguidos.
3. 📄 Selecciona el formato JSON.
4. 💻 Una vez descargado el archivo, compara las listas con un script sencillo o herramienta local para ver los usuarios que no corresponden el seguimiento y depurarlos manualmente a tu propio ritmo.

Cuidar la salud de tu cuenta requiere paciencia y constancia. Configurar tiempos realistas y apoyarte en herramientas transparentes te permitirá mantener un perfil optimizado y libre de cuentas fantasma sin poner en riesgo tu seguridad.

¿Tienes una biblioteca repleta de películas, series, documentales o música y quieres acceder a ella desde cualquier televisor, smartphone o consola de tu casa? Crear tu propio servidor multimedia personal es la mejor decisión que puedes tomar.

Cuando pensamos en servidores domésticos, solemos imaginar distribuciones tradicionales como Ubuntu Server o Debian. Sin embargo, CachyOS —la distribución ultrarrápida basada en Arch Linux y optimizada para procesadores modernos— es una opción formidable para este propósito. Gracias a sus optimizaciones de kernel y su gestión de rendimiento en tiempo real, tu servidor multimedia volará. ⚡

En esta guía práctica y directa al grano, aprenderás cómo instalar, configurar y sacarle el máximo provecho a Plex Media Server en CachyOS, paso a paso y sin complicaciones. ¡Manos a la obra! 🛠️

1. ¿Por qué elegir CachyOS para tu servidor Plex? 🏎️

Antes de entrar en comandos de terminal, vale la pena entender qué ventajas aporta CachyOS a un entorno multimedia:

1. Rendimiento compilado para tu procesador: CachyOS aprovecha las instrucciones avanzadas (x86-64-v3 y v4), lo que reduce el uso innecesario de ciclos de CPU.
2. Kernels optimizados (BORE / EEVDF): Gestionan de forma sobresaliente los procesos en segundo plano. Mientras Plex escanea metadatos o convierte un video, el resto del sistema no sufre tirones.
3. Drivers gráficos al día: Al estar basada en Arch Linux con modelo rolling release, cuentas siempre con las versiones más recientes de Mesa, VA-API y controladores de video para transcodificación por hardware.

2. Requisitos previos y puesta a punto del sistema 💻

Para comenzar con buen pie, es importante que tu instalación de CachyOS esté completamente actualizada y cuente con las herramientas esenciales de desarrollo y compilación.

Abre tu emulador de terminal favorito y ejecuta:

Bash

# 1. Actualizar repositorios y paquetes del sistema
sudo pacman -Syu

# 2. Instalar herramientas de compilación básicas
sudo pacman -S --needed base-devel git

Verifica también que cuentas con un asistente para AUR (Arch User Repository) como paru o yay.

3. Método 1: Instalación Nativa vía AUR (Recomendado) 📦

La instalación nativa es la opción más directa y ligera, ya que integra Plex como un servicio nativo del sistema operativo gestionado por systemd.

Paso 1: Descargar e instalar el paquete

Ejecuta el siguiente comando con tu gestor AUR:

Bash

paru -S plex-media-server

(Si utilizas yay, simplemente sustituye paru por yay).

El asistente compilará e integrará los binarios oficiales de Plex en el sistema.

Paso 2: Habilitar e iniciar el servicio

Una vez terminada la instalación, debemos indicarle al sistema que arranque Plex inmediatamente y que lo inicie de forma automática cada vez que enciendas el equipo:

Bash

sudo systemctl enable --now plexmediaserver.service

Paso 3: Comprobar el estado

Para asegurarte de que el servicio está funcionando sin errores, ejecuta:

Bash

systemctl status plexmediaserver.service

Si todo ha ido bien, verás un punto verde indicando que el estado es active (running). ✅

4. Método 2: Despliegue mediante Docker y Docker Compose 🐳

Si prefieres aislar Plex del sistema base o planeas combinarlo con otras aplicaciones (como gestores de descargas o paneles de control), Docker es una alternativa modular y muy ordenada.

Paso 1: Instalar el motor Docker

Bash

sudo pacman -S docker docker-compose
sudo systemctl enable --now docker.service
sudo usermod -aG docker $USER

(Nota: Cierra y vuelve a abrir tu sesión de usuario para que el grupo Docker tome efecto).

Paso 2: Crear el archivo docker-compose.yml

Crea una carpeta para el proyecto y dentro genera el archivo de configuración:

Bash

mkdir -p ~/servidor-plex && cd ~/servidor-plex
nano docker-compose.yml

Pega la siguiente configuración (usando la imagen oficial de LinuxServer):

YAML

services:
  plex:
    image: lscr.io/linuxserver/plex:latest
    container_name: plex
    network_mode: host
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/Mazatlan
      - VERSION=docker
    volumes:
      - ./config:/config
      - /mnt/almacenamiento/series:/tv
      - /mnt/almacenamiento/peliculas:/movies
    restart: unless-stopped

Paso 3: Levantar el contenedor

Para ponerlo en marcha en segundo plano:

Bash

docker compose up -d

5. El Gran Dolor de Cabeza en Linux: Permisos y Discos Secundarios 🔑

El 90% de los problemas en Plex bajo Linux ocurren cuando el servidor no puede ver las películas que tienes guardadas en tus discos.

En la instalación nativa, el servidor se ejecuta bajo el usuario del sistema plex. Este usuario necesita permisos de lectura y ejecución en las carpetas donde guardas tu contenido.

Regla de oro: No guardes medios dentro de tu /home

Evita colocar tus carpetas de películas dentro de /home/tu_usuario/. En Arch Linux y CachyOS, los directorios personales tienen permisos estrictos (700 o 750) que bloquean el acceso a cualquier servicio externo.

👉 Lo ideal es utilizar un punto de montaje en la raíz, como /mnt/almacenamiento o /media/multimedia.

Asignar permisos correctos (Formato Linux: ext4 / btrfs)

Si tus discos tienen formato de Linux, ejecuta estos comandos para garantizar lectura:

Bash

# Permisos 755 a todas las carpetas (para poder entrar y leerlas)
sudo find /mnt/almacenamiento -type d -exec chmod 755 {} +

# Permisos 644 a todos los archivos multimedia
sudo find /mnt/almacenamiento -type f -exec chmod 644 {} +

Montaje automático en /etc/fstab 📌

Para que tus discos duros secundarios o externos no desaparezcan al reiniciar el equipo, agrégalos a tu archivo de montajes permanente.

1. Identifica el UUID de tu disco:

Bash

lsblk -f

2. Abre el archivo de configuración:

Bash

sudo nano /etc/fstab

3. Añade la línea correspondiente al final del archivo:

• Para discos en formato ext4:

Plaintext

UUID=tu-uuid-aqui   /mnt/almacenamiento   ext4   defaults,noatime   0   2

• Para discos en formato NTFS (discos que usabas en Windows):

Plaintext

UUID=tu-uuid-aqui   /mnt/almacenamiento   ntfs-3g   uid=plex,gid=plex,dmask=022,fmask=133,windows_names   0   0

Guarda los cambios con Ctrl + O y sal con Ctrl + X.

6. Primer Acceso y Reclamar el Servidor 🌐

¡Es momento de entrar a la interfaz web y vincular tu cuenta de Plex!

1. Abre tu navegador web e ingresa a la siguiente dirección:Plaintexthttp://localhost:32400/web
2. Inicia sesión con tu cuenta de Plex (o regístrate gratis si aún no tienes una).
3. Sigue el asistente de bienvenida: asígnale un nombre a tu servidor (ejemplo: Servidor-CachyOS) y marca la casilla para permitir el acceso a tus medios fuera del hogar si lo requieres.
4. Añade tus bibliotecas: Selecciona si vas a añadir Películas, Series o Música y navega hasta la ruta de tus carpetas (ej. /mnt/almacenamiento/peliculas).

7. Optimización y Transcodificación por Hardware ⚙️

La transcodificación ocurre cuando el dispositivo donde reproduces el video no soporta el formato nativo del archivo (por ejemplo, reproducir un archivo 4K HEVC en un navegador web antiguo).

Si tienes una suscripción activa a Plex Pass, puedes transferir esta carga pesada del procesador a tu tarjeta gráfica integrada o dedicada:

Para asegurarte de que el usuario plex puede interactuar directamente con la GPU en una instalación nativa, agrégalo al grupo de video y render:

Bash

sudo usermod -aG video,render plex
sudo systemctl restart plexmediaserver.service

8. Configuración del Firewall y Acceso Remoto 🛡️

Si tienes activado un cortafuegos local (como ufw o firewalld), asegúrate de habilitar los puertos clave de Plex para que tus smart TVs y dispositivos móviles en la red local puedan comunicarse sin bloqueos:

Bash

# Si usas UFW:
sudo ufw allow 32400/tcp comment 'Plex Web & Media'
sudo ufw allow 1900/udp comment 'Plex DLNA'
sudo ufw allow 5353/udp comment 'Plex Discovery'
sudo ufw reload

9. Preguntas Frecuentes (FAQ) ❓

¿Plex es completamente gratuito?

Sí. Puedes ver todo tu contenido en red local, organizar bibliotecas con carátulas automáticas y reproducir en Smart TVs de forma 100% gratuita. Funciones avanzadas como la transcodificación por hardware o las descargas sin conexión requieren la suscripción opcional Plex Pass.

¿Cómo actualizo Plex en CachyOS?

Si instalaste mediante el método nativo (AUR), se actualizará automáticamente cada vez que actualices el sistema con paru -Syu o yay -Syu. Si usas Docker, basta con ejecutar docker compose pull y luego docker compose up -d.

¿Puedo acceder a mis películas desde fuera de mi casa?

Sí. En la sección Ajustes > Acceso Remoto de Plex puedes habilitar esta opción. Si tu router cuenta con UPnP funcionará automáticamente; de lo contrario, solo necesitas abrir y redirigir el puerto 32400 en el panel de control de tu router hacia la IP local de tu servidor.

Conclusión 🏁

Montar tu servidor Plex en CachyOS combina lo mejor de dos mundos: la inmensa versatilidad del ecosistema Arch Linux y la potencia de un kernel optimizado al milímetro para exprimir cada ciclo de tu hardware.

Siguiendo esta guía ya cuentas con un centro multimedia sólido, rápido y accesible desde cualquier rincón de tu hogar. ¡Prepara las palomitas y a disfrutar de tus contenidos favoritos! 🍿🎉

Si estás integrando SAP Business One Service Layer con una aplicación propia en PHP o CodeIgniter 4 para gestionar empleados y sus roles, es muy probable que en algún momento te topes con este comportamiento extraño: haces un PATCH a EmployeesInfo quitando un rol del arreglo EmployeeRolesInfoLines, Service Layer te responde 204 (éxito), pero al consultar de nuevo el empleado… el rol sigue ahí.

No es un bug de tu código. Es un comportamiento documentado (pero poco conocido) de cómo Service Layer maneja las colecciones hijas en las peticiones PATCH. En este post te explico la causa exacta y la solución con un ejemplo completo en PHP.

El síntoma

Un flujo típico para quitar un rol asignado a un empleado se ve así:

1. Haces GET a EmployeesInfo(empID) y traes la colección EmployeeRolesInfoLines.
2. Filtras en tu código el rol que quieres eliminar.
3. Mandas un PATCH de vuelta con el arreglo ya sin ese rol.
4. Service Layer responde HTTP 204 No Content — es decir, “todo salió bien”.
5. Vuelves a consultar el empleado… y el rol que “eliminaste” sigue en la lista.

El código no marca ningún error. El log de tu aplicación dice que la operación fue exitosa. Y sin embargo, en SAP no pasó nada.

La causa real: cómo funciona PATCH en Service Layer

Aquí está la clave que casi nadie documenta claramente: PATCH en SAP Business One Service Layer nunca elimina elementos de una colección hija por el simple hecho de omitirlos del arreglo.

Por definición, PATCH es una actualización parcial: aplica los cambios que le mandas y conserva silenciosamente todo lo que no esté presente en el payload. Si en tu arreglo EmployeeRolesInfoLines ya no incluyes el rol que querías borrar, Service Layer no lo interpreta como “bórralo” — simplemente lo ignora y lo deja como estaba.

Este mismo comportamiento se ha reportado en la comunidad de desarrolladores de SAP al trabajar con líneas de documentos (DocumentLines en órdenes de venta), y aplica exactamente igual a cualquier colección hija expuesta por Service Layer, incluyendo los roles de un empleado.

La solución: el header B1S-ReplaceCollectionsOnPatch

Service Layer sí tiene una forma de decirle “trata este arreglo como el reemplazo completo de la colección, no como una actualización parcial”: el header HTTP B1S-ReplaceCollectionsOnPatch: true.

Al incluir este header en tu petición PATCH, cualquier elemento que no esté presente en el arreglo que envías sí se elimina de la colección hija en SAP. Es exactamente el comportamiento que necesitas para dar de baja un rol.

⚠️ Importante antes de usarlo

Este header cambia el comportamiento para todas las colecciones hijas incluidas en ese PATCH, no solo la que te interesa. Si tu payload incluyera más de una colección hija, cualquiera que no mandes completa corre el riesgo de perder elementos. La recomendación es:

• Usarlo únicamente en los endpoints donde manipulas directamente EmployeeRolesInfoLines (agregar/quitar roles).
• No incluirlo en el PATCH general de datos del empleado (nombre, departamento, estatus), donde no estás tocando colecciones hijas.

Ejemplo completo en PHP (CodeIgniter 4)

Así queda la función completa para eliminar un rol de un empleado, con el flujo GET → filtrar → PATCH con el header correcto:

php

public function removeEmployeeRole($empID, $roleID) {
    helper('auth');
    $userName = user()->username;
    $empID = (int) $empID;
    $roleID = (int) $roleID;

    if ($empID <= 0 || $roleID <= 0) {
        return $this->respond(['status' => 400, 'message' => 'Faltan datos'], 400);
    }

    $dataSL = $this->serviceLayerModel->first();
    if (empty($dataSL)) {
        return $this->respond(['status' => 500, 'message' => 'No hay configuración Service Layer'], 500);
    }

    try {
        $conexionSap = $this->serviceLayerController->login(
                $dataSL['url'],
                $dataSL['port'],
                $dataSL['password'],
                $dataSL['username'],
                $dataSL['companyDB']
        );
    } catch (\Exception $e) {
        return $this->respond(['status' => 500, 'message' => 'Error login SL: ' . $e->getMessage()], 500);
    }

    if (empty($conexionSap->SessionId)) {
        return $this->respond(['status' => 500, 'message' => 'No se obtuvo SessionId'], 500);
    }

    $cookie = "B1SESSION=" . $conexionSap->SessionId . "; ROUTEID=.node1";
    $slRoot = rtrim($dataSL['url'], '/');
    if (stripos($slRoot, '/b1s/v1') === false) {
        $slRoot .= '/b1s/v1';
    } else {
        $pos = stripos($slRoot, '/b1s/v1');
        $slRoot = substr($slRoot, 0, $pos) . '/b1s/v1';
    }

    $getHeaders = [
        "Accept: application/json",
        "Content-Type: application/json",
        "User-Agent: PHP",
        "B1S-CaseInsensitive: true"
    ];

    // Header clave: le dice a Service Layer que reemplace por completo
    // la colección hija, en vez de solo actualizar/agregar elementos
    $patchHeaders = array_merge($getHeaders, [
        "B1S-ReplaceCollectionsOnPatch: true"
    ]);

    // 1) GET de los roles actuales
    $getUrl = $slRoot . "/EmployeesInfo({$empID})?" . http_build_query([
        '$select' => 'EmployeeID,EmployeeRolesInfoLines'
    ]);

    $ch = curl_init();
    curl_setopt_array($ch, [
        CURLOPT_URL => $getUrl,
        CURLOPT_PORT => $dataSL['port'],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_COOKIE => $cookie,
        CURLOPT_SSL_VERIFYHOST => false,
        CURLOPT_SSL_VERIFYPEER => false,
        CURLOPT_HTTPHEADER => $getHeaders,
        CURLOPT_TIMEOUT => 60
    ]);
    $getResp = curl_exec($ch);
    $getErr = curl_error($ch);
    $getHttp = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($getErr || $getHttp < 200 || $getHttp >= 300) {
        return $this->respond([
            'status' => 500,
            'message' => 'Error al obtener roles actuales: ' . ($getErr ?: "HTTP $getHttp: $getResp")
        ], 500);
    }

    $current = json_decode($getResp, true);
    $roles = $current['EmployeeRolesInfoLines'] ?? [];

    // 2) Filtrar quitando el rol indicado
    $newRoles = array_values(array_filter($roles, function ($r) use ($roleID) {
        return (int) ($r['RoleID'] ?? 0) !== $roleID;
    }));

    if (count($newRoles) === count($roles)) {
        return $this->respond([
            'status' => 404,
            'message' => 'El empleado no tiene asignado ese rol'
        ], 404);
    }

    // 3) PATCH con la colección ya sin ese rol + header de reemplazo total
    $patchUrl = $slRoot . "/EmployeesInfo({$empID})";
    $payload = ['EmployeeRolesInfoLines' => $newRoles];

    $ch = curl_init();
    curl_setopt_array($ch, [
        CURLOPT_URL => $patchUrl,
        CURLOPT_PORT => $dataSL['port'],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CUSTOMREQUEST => 'PATCH',
        CURLOPT_POSTFIELDS => json_encode($payload),
        CURLOPT_COOKIE => $cookie,
        CURLOPT_SSL_VERIFYHOST => false,
        CURLOPT_SSL_VERIFYPEER => false,
        CURLOPT_HTTPHEADER => $patchHeaders,
        CURLOPT_TIMEOUT => 60
    ]);
    $resp = curl_exec($ch);
    $err = curl_error($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($err) {
        return $this->respond(['status' => 500, 'message' => 'cURL Error: ' . $err], 500);
    }

    if ($httpCode < 200 || $httpCode >= 300) {
        $body = json_decode($resp, true);
        return $this->respond(['status' => $httpCode, 'message' => 'Error al eliminar', 'body' => $body], $httpCode);
    }

    $this->log->save([
        "description" => "Eliminación de rol ID '$roleID' del empleado $empID (vía SL, EmployeesInfo/EmployeeRolesInfoLines)",
        "user" => $userName
    ]);

    // Normalizado a 200 siempre en éxito, sin importar si SAP regresó 204
    return $this->respond(['status' => 200, 'message' => 'Rol eliminado correctamente'], 200);
}

Puntos clave para recordar

• PATCH en Service Layer nunca borra por omisión. Si un elemento de una colección hija no aparece en el arreglo que envías, se conserva tal cual.
• B1S-ReplaceCollectionsOnPatch: true convierte ese comportamiento en un reemplazo completo: lo que no incluyas en el arreglo, se elimina.
• El patrón correcto para editar colecciones hijas (agregar, actualizar o quitar) sigue siendo GET → modificar en tu código → PATCH con la colección completa — la diferencia está en agregar este header cuando el objetivo es que también se eliminen elementos.
• Aplica este header únicamente en los endpoints que manipulan la colección específica; no lo agregues de forma global a todos tus PATCH contra EmployeesInfo.
• Un 204 No Content de Service Layer confirma que la petición fue válida, no que hizo lo que tú esperabas — siempre vale la pena verificar el resultado real, sobre todo mientras ajustas la lógica de colecciones hijas.

Si estás integrando otros módulos de SAP B1 vía Service Layer (órdenes de venta, líneas de documento, direcciones de socios de negocio), este mismo principio aplica: cualquier colección hija (DocumentLines, Addresses, ContactEmployees, etc.) se comporta igual ante un PATCH normal.

Si acabas de instalar PHP 8.3 en CachyOS (o cualquier derivado de Arch) desde AUR y te encontraste con una cascada interminable de errores de composer update pidiendo extensiones que “deberían venir incluidas”, esta guía es para ti. Documentando el proceso completo que seguí para dejar funcionando un proyecto CodeIgniter 4 con dependencias de facturación electrónica (CFDI).

El problema: PHP en Arch viene troceado en paquetes AUR separados

A diferencia de otras distros donde php trae casi todo integrado, en Arch/CachyOS el paquete php83 del AUR está dividido en subpaquetes independientes por extensión (php83-dom, php83-xsl, php83-mysql, etc.), todos derivados del mismo pkgbase. Esto significa dos cosas importantes:

1. Ninguna extensión “viene por defecto” — hay que instalarlas explícitamente.
2. Como comparten pkgbase, instalar una sola extensión nueva obliga a recompilar PHP completo, junto con todas las extensiones que ya tenías.

Síntoma inicial: Composer ni siquiera arranca

PHP Warning:  PHP Startup: Unable to load dynamic library 'phar'...
PHP's phar extension is missing. Composer requires it to run.

Sin phar, Composer no corre. Punto de partida obligado.

Los errores en cadena de composer update

Una vez con phar instalado, cada corrida de composer update revela otra extensión faltante:

- phpcfdi/cfdi-to-json require ext-dom * -> it is missing from your system.
- eclipxe/cfdiutils require ext-xsl * -> it is missing from your system.

Composer te va soltando las dependencias una por una, no de golpe — así que si vas resolviendo extensión por extensión, terminas recompilando PHP completo varias veces por la naturaleza del pkgbase compartido.

La solución: instalar todo en un solo lote, desatendido

En vez de ir corrigiendo extensión por extensión (y recompilar PHP 5-6 veces), la jugada es instalar de una sola vez todas las extensiones que un stack típico de CI4 + CFDI (facturación electrónica) va a necesitar:

yay -S --noconfirm --answerdiff None --answerclean All --removemake --cleanafter \
  php83-xsl php83-soap php83-bcmath php83-simplexml php83-tokenizer php83-fileinfo \
  php83-ctype php83-dom php83-xml php83-xmlreader php83-xmlwriter php83-iconv

Qué hace cada flag

Con esto, yay corre de principio a fin sin pedir intervención manual, y como todas las extensiones comparten pkgbase, PHP se recompila una sola vez con todo el set incluido — en vez de una recompilación completa por cada extensión suelta.

Por qué justo estas extensiones

Si trabajas con librerías de facturación electrónica mexicana (CFDI) vía Composer (eclipxe/cfdiutils, phpcfdi/cfditopdf, etc.), este es el patrón típico de requisitos:

• xsl, dom, xml, xmlreader, xmlwriter, simplexml — parseo y transformación de los XML del CFDI/timbrado.
• soap — comunicación con PACs (Proveedores Autorizados de Certificación) para timbrado.
• bcmath — cálculos de precisión decimal en montos, impuestos y totales.
• tokenizer, ctype, fileinfo, iconv — requisitos base de CodeIgniter 4 y de muchos paquetes Composer modernos.

Verificación final

Una vez terminada la instalación:

php83 -m | grep -Ei 'dom|xsl|soap|bcmath|xml|tokenizer|ctype|fileinfo|iconv'
composer update

Si composer update resuelve sin errores de ext-* faltante, ya está: tu entorno CachyOS queda listo para correr CodeIgniter 4 con dependencias de facturación electrónica sin más sorpresas.

Bonus: evita recompilar cada vez que necesites otra extensión

Si en el futuro te falta una extensión nueva y no quieres esperar otra compilación completa del pkgbase de PHP, vale la pena activar Chaotic-AUR, un repositorio de binarios precompilados para paquetes de AUR (incluyendo todo el árbol php83-*):

sudo pacman-key --recv-key 3056513887B78AEB --keyserver keyserver.ubuntu.com
sudo pacman-key --lsign-key 3056513887B78AEB
sudo pacman -U 'https://cdn-mirror.chaotic.cx/chaotic-aur/chaotic-keyring.pkg.tar.zst' \
               'https://cdn-mirror.chaotic.cx/chaotic-aur/chaotic-mirrorlist.pkg.tar.zst'

Y agregando al final de /etc/pacman.conf:

[chaotic-aur]
Include = /etc/pacman.d/chaotic-mirrorlist

Con eso, la próxima extensión que necesites se instala en segundos vía pacman, sin pasar por makepkg.

Resumen para el que tenga prisa: en CachyOS/Arch, PHP viene fragmentado por extensión en AUR bajo un mismo pkgbase. En vez de ir instalando una por una según te las va pidiendo Composer, identifica de una vez el set completo que necesita tu stack (CI4 + CFDI, en mi caso) e instálalo todo junto con yay -S --noconfirm --answerdiff None --answerclean All --removemake --cleanafter <paquetes>. Te ahorras varias recompilaciones completas del core de PHP.