Saltar a contenido

Probar en local

El kit de Node es la carpeta sdk/ de los plugins de ejemplo (de dónde sacarla), y está también solo en kinotvapp/kino-plugin-sdk: run.mjs (ejecuta una función), validate.mjs (revisa un plugin como lo hace Kino), init.mjs (crea el esqueleto de uno nuevo), kino-shim.mjs (la API kino en Node), contract.mjs (las reglas, leídas de contract.json), seal.mjs (sella un secreto para tu manifiesto, y con --keygen/--sign firma un plugin firmado) y guide-tables.mjs (regenera las tablas de la guía) y ui-tables.mjs (regenera las tablas de los componentes de pantalla). No hay nada que instalar. Necesita Node 18 o más nuevo (probado en 18.20, 20.11 y 24.14); node --test sdk/test/kit.test.mjs ejecuta sus propias pruebas.

node sdk/run.mjs ./plugin.js search "metropolis"
node sdk/run.mjs ./plugin.js home
node sdk/run.mjs ./plugin.js browse films 2
node sdk/run.mjs ./plugin.js episodes 'Dragnet1951'
node sdk/run.mjs ./plugin.js resolve 'Dragnet1951|Dragnet/Season 1/Dragnet (1951) - S01E01 - The Human Bomb.mp4'

El primer argumento es tu archivo de entrada (o la carpeta que tiene kino-plugin.json), luego la función, luego su argumento: el texto a buscar, el ref para episodes y resolve, o el ref y un cursor opcional para browse. El runner lee tu manifiesto, pone el global kino, llama esa única función como lo hace Kino, revisa la respuesta con las reglas de la app e imprime en stdout, como JSON, lo que Kino conservaría; cada entrada que Kino descartaría sale en stderr con el motivo (--raw imprime tu respuesta sin tocar). Los logs, console.* y los errores van a stderr, así que puedes encadenar el resultado (... | head -30, ... | jq). El código de salida es 0 si todo sale bien, 1 cuando tu código lanza un error y 2 cuando el comando está mal. El runner solo ejecuta funciones que tu manifiesto declara.

  • --config key=value (repetible) fija un ajuste; el runner también lee sdk/config.json ({ "server": "http://192.168.1.10:8096", "user": "ana" }; déjalo por fuera de git). Un ajuste obligatorio sin valor frena la ejecución con auth_required, como en la app.
  • --record fixtures.json guarda cada respuesta de kino.fetch; --replay fixtures.json responde solo desde ese archivo, sin red. Graba una vez y tus pruebas corren sin conexión y siempre igual (el test/plugin.test.mjs del esqueleto hace exactamente eso).
  • --device tv|phone (o KINO_DEVICE=tv) fija lo que dice kino.device, para probar el lado de TV de tu plugin; por defecto es "phone". Cualquier otro valor frena la ejecución.
  • KINO_TYPE=movie|series|music|podcast|any fija el type de la búsqueda (por defecto any; music y podcast son de apiVersion 8, Kino 0.9.54).
  • Para llenar los otros campos de la consulta, pasa la consulta completa como JSON: node sdk/run.mjs ./plugin.js search '{"q":"dragnet","type":"series","year":1951}' (season, episode, tmdbId y year son 0 si no).
  • En el kit de Node, kino.storage es un archivo llamado .kino-storage.json y el tarro de cookies .kino-cookies.json, los dos al lado de tu manifiesto. Agrégalos a tu .gitignore. Bórralos para empezar de cero. Un plugin con secrets también lee .kino-secrets.json de la misma carpeta (abajo). node sdk/init.mjs ya pone los tres en el .gitignore del esqueleto.
  • node sdk/validate.mjs <folder> revisa el manifiesto con todas las reglas de el manifiesto (los mismos mensajes en español que muestra la app) y que cada capacidad declarada esté exportada, e imprime las líneas extra de la hoja de consentimiento tal como las leerá la persona (las rojas, un host insecureHttp, "liveStreamHosts": "any" o "streamHosts": "any", marcadas "(en rojo)"; secrets agrega "Usa datos sellados por su autor", con una nota de que solo la app puede comprobar para qué repositorio se sellaron); --run <function> [argument] además la ejecuta y lista lo que Kino descartaría. Con --run liveCategories, cada lista declarada también se descarga y se analiza: una que no se puede descargar o que da 0 canales es un problema, y se listan sus entradas descartadas. Con --run meta <ids> le pregunta a tu meta (abajo). --run section [tab], --run categories, --run settingsStatus, --run action <key> y --run validateSettings '<json>' (apiVersion 6) las ejecutan como run.mjs y como las lee la app: la sección y las categorías con lo que se descarta, cada línea de estado y las que faltan, lo que muestra una acción (y si refresca o borra ajustes), y si se acepta el guardado. Una llamada que la app nunca hace es un problema: no hay "section" en el manifiesto, categories sin apiVersion 6 y browse, una clave de acción que ningún ajuste action tiene, una función que no se exporta, o una respuesta de validateSettings que Kino no puede leer. El código de salida 0 significa que Kino la aceptaría.
  • La carpeta sdk/ no tiene que vivir en tu repositorio. Cópiala a cualquier parte y ejecuta node /ruta/a/sdk/run.mjs ./plugin.js ....
  • Un stack trace nombra un plugin.mjs temporal: el runner carga una copia de tu archivo para que Node lo trate como módulo ES sin importar su versión ni lo que diga package.json. Los números de línea son los de tu plugin.js.

Copiar el kit a un plugin nuevo

Un repositorio creado con Use this template ya trae el kit. Si en cambio empiezas con node sdk/init.mjs, copia el kit junto al kino-plugin.json del plugin nuevo: la carpeta sdk/ y el archivo contract.json (el kit lo busca junto a sdk/: los dos son obligatorios; kino.d.ts es opcional, solo para los tipos de tu editor, porque el kit nunca lo lee). Deja fuera sdk/test/: son las pruebas del propio kit (más de 60 archivos), no le sirven a un plugin, y un node --test sin nombre las ejecutaría. Cópialo sin esa carpeta, o bórrala después:

cp -r kino-plugin-sdk/sdk kino-plugin-sdk/contract.json kino-plugin-sdk/kino.d.ts mi-plugin/
rm -rf mi-plugin/sdk/test        # PowerShell: Remove-Item -Recurse -Force mi-plugin\sdk\test

Un plugin creado desde una plantilla también trae sdk/test/: bórrala igual. Nada de sdk/ lee sdk/test/ al ejecutarse; las pruebas de tu plugin viven en test/, y las ejecutas por su nombre (node --test test/plugin.test.mjs).

Secretos sellados (apiVersion 4)

El kit nunca puede abrir un sello: no tiene la clave privada. Por eso lee los valores en claro directamente de .kino-secrets.json al lado de tu manifiesto ({ "apiKey": "..." }; déjalo fuera de git, como hace el .gitignore del esqueleto) y simula todas las reglas de kino.secret: los marcadores, el cambio dentro de kino.fetch, la revisión de hosts del manifiesto por https en cada salto, las restricciones de kino.crypto y el tapado de lo que vuelve. --record tampoco escribe nunca el valor en claro en un archivo de fixtures: en su lugar va un marcador fijo, así que una grabación que subes a git nunca lleva un secreto, se reproduzca como se reproduzca después.

Para hacer el sello: node sdk/seal.mjs --repo owner/repo --name apiKey, y escribe el valor en el prompt oculto (o pásalo por stdin). Sella para el repositorio desde el que la gente va a instalar, y prueba la versión sellada en la app instalada desde su rama principal, sin @ref (por qué).

Plugins firmados (apiVersion 5)

validate.mjs comprueba un plugin firmado como lo hace Kino: la forma del campo signature, la firma misma contra tu archivo de entrada (--repo owner/repo[/carpeta], o el origin de GitHub de la carpeta si lo omites), que ningún *.pem esté rastreado por git, e imprime la huella de la clave del autor y la línea de consentimiento "Firmado por su autor". También rechaza "entry": "./plugin.js" (Kino 0.9.45 y anteriores no lo instalan) y avisa cuando hosts tiene más de 20 entradas (Kino 0.9.44 y anteriores lo rechazan). Firma otra vez después de cada cambio en el archivo de entrada o en la version.

Canales en vivo (apiVersion 3)

Los exports de channels se ejecutan con live, con la carpeta del plugin primero:

node sdk/run.mjs . live categories
node sdk/run.mjs . live channels noticias
node sdk/run.mjs . live channels noticias 2
node sdk/run.mjs . live guide canal1,canal2
node sdk/run.mjs . live search noticias
node sdk/run.mjs live playlist https://iptv-org.github.io/iptv/countries/co.m3u
node sdk/run.mjs live playlist ./lista.m3u --epg ./guia.xml.gz
  • live categories llama liveCategories() e imprime lo que Kino conserva. Luego, por cada { playlist } de la respuesta, descarga la lista como lo haría la app (tus headers, solo tus hosts o el servidor de la persona, cada redirección también) e imprime, en stderr, el mismo resumen que live playlist y los grupos de la lista como las categorías que verá la gente.
  • live channels <categoryId> [cursor] llama liveChannels({ categoryId, cursor }) y luego reproduce, como lo haría Kino, el primer canal que tenga ref y no stream: le manda ese ref a resolve() y revisa la respuesta como la de un canal en vivo (así que aplica "liveStreamHosts": "any"). Con validate.mjs --run liveChannels, una respuesta rechazada ahí es un problema.
  • live search <consulta> llama liveSearch({ query }), imprime los canales que Kino conserva (máximo 100) y reproduce el primero que tenga ref, como live channels.
  • resolve <ref> --live revisa una respuesta de resolve() como la de un canal en vivo. Sin --live el kit no puede saber que el ref es de un canal y aplica la regla estricta; cuando solo eso frena la URL y tu manifiesto tiene "liveStreamHosts": "any", dice "si este ref es de un canal en vivo, prueba con --live".
  • live guide <id,id> llama guide() con esos ids y una ventana de 24 horas que empieza dos horas atrás.
  • live playlist <url|file> no necesita plugin: lee cualquier lista M3U con las reglas de Kino e imprime N canales en M categorías; K entradas descartadas; L ocultas (adultos), las categorías y los primeros 20 canales como group › name url. Con --epg <url|file> también muestra qué tiene al aire cada uno de esos 20, o "sin guía". Una guía que declara un DOCTYPE se rechaza, como en la app, y el comando lo dice: "La guía declara un DOCTYPE; Kino la rechaza por seguridad". Úsalo con una lista antes de escribir una sola línea de plugin.

El kit lee listas y guías con sdk/live-playlist.mjs, una copia de los lectores de la app amarrada a los mismos archivos de prueba (docs/plugins/fixtures/live en el repositorio de Kino): lo que conserva es lo que conserva Kino.

Lo nuevo de apiVersion 6

node sdk/run.mjs . section [tab]                  # necesita "section" en el manifiesto
node sdk/run.mjs . categories                     # necesita la capacidad browse
node sdk/run.mjs . theme                          # tus colores, sus contrastes y sus respaldos
node sdk/run.mjs . settingsStatus
node sdk/run.mjs . action logout
node sdk/run.mjs . validateSettings '{"email":"ana@x.co"}'
node sdk/run.mjs --within '<ref>' ./plugin.js search "texto"   # scopedSearch
node sdk/run.mjs ./plugin.js sign '{"url":"https://cdn.example/seg.ts","kind":"segment","ref":"<ref>","context":"<signContext>"}'
node sdk/run.mjs --retry conflict:1 ./plugin.js resolve '<ref>'  # o conflict:1:409
node sdk/validate.mjs . --run liveSearch noticias  # marca +18 de los resultados de liveSearch
node sdk/run.mjs ./plugin.js migrate '{"kind":"title","ref":"<ref viejo>"}'

run.mjs muestra como [dropped by Kino] lo que Kino descartaría (clearSettings, alternateHosts), imprime lo que leería la persona con un userMessage (o por qué no se mostraría), y validate.mjs avisa de debug antes de publicar, de un scopedSearch que nunca lee within y de un plugin que usa los pares de llaves de kino.crypto sin "apiVersion": 6. Las páginas: Formulario de ajustes, Firma por petición, Pasar lo guardado, Sección, categorías y colores, Registro y telemetría.

Describir títulos (meta)

node sdk/run.mjs . meta tt1254207 tmdb:10378        # apiVersion 6, "meta": Kino's verdict field by field and the info page
node sdk/validate.mjs . --run meta tt1254207        # the same, as a check; null is a note, not a problem

meta <ids> [movie|series] llama tu meta() con la consulta que arma Kino para un título que listó otra fuente, { type, ids: { imdb?, tmdb?, kitsu?, mal?, anilist? }, id?, lang? }: tt… es ids.imdb, tmdb:N es ids.tmdb, y kitsu:N, mal:N, anilist:N fijan ese id y el id de la consulta (el id propio de la fuente, como en un anime de Stremio); lang=xx (por defecto KINO_LANG, si no es), id=<id de la fuente>, o la consulta entera como JSON. Nunca recibe un ref: Kino describe un título por sus ids, sea cual sea el plugin que lo listó, y no le pregunta a nadie por un título sin ids. La llamada tiene los 6 s de Kino; pasado ese tiempo el kit deja de esperar, como la app. Por stderr: la consulta, tu respuesta tal como la devolviste, el veredicto de Kino campo por campo (✓ se conserva, ~ se corta o se conserva en parte, ✗ se descarta, · no está, - se ignora, con el motivo de cada entrada descartada) y luego cómo la usaría la ficha; por stdout, lo que Kino conserva (null cuando no cuenta como respuesta). Si el manifiesto declara meta y el archivo de entrada no lo exporta, el runner dice que Kino rechaza la instalación. Una ejecución recortada con el plugin de referencia del servidor propio (Tu servidor 1.5.0, con su server.mjs corriendo):

$ node sdk/run.mjs --config server=http://192.168.2.13:18096 --config user=ana --config password=s3cr3t . meta tt1254207 tmdb:10378
meta({"type":"movie","ids":{"imdb":"tt1254207","tmdb":10378},"lang":"es"})
the plugin answered:
{ … }
Kino's verdict, field by field:
  ✓ title           kept: 14 characters; the page keeps the source's own title, this one is not shown
  ✓ overview        kept: 73 characters; shown as the synopsis when TMDB and AniList have none (HTML tags stripped)
  ✓ poster          kept: http://192.168.2.13:18096/img/poster/bbb.png (a server the person typed); used when the page has no poster
  ✓ year            kept: 2008
  ✓ genres          kept: 2 of 2: Animación, Comedia
  ✓ runtimeMinutes  kept: 10; shown only for a movie (a series' runtime is per episode)
  · episodes        absent: not given
  ✓ ratings         kept: 2 of 2: imdb 6.4, letterboxd 3.4/5
  ✓ cast            kept: 2 of 2
{ … }
How the info page would use it (only where TMDB and AniList left the part blank; their values always win):
  info line: ★ <the page's score>  ·  IMDb 6.4  ·  Letterboxd 3.4/5  ·  2008  ·  10 min
  synopsis: Un conejo enorme y tranquilo contra tres roedores que no lo dejan en paz.
  …

Una parte descartada se lee como ✗ backdrop dropped: 192.168.1.4 is a private, local or reserved IP address: never the home network, y una lista con entradas malas como ~ ratings partly kept: 3 of 4: … seguida de una línea por entrada. Las mismas reglas corren sobre los vectores de prueba de la propia app (docs/plugins/fixtures/meta/vectors.json en el repositorio de Kino), así que lo que conserva el kit es lo que conserva Kino.

validate.mjs --run también encadena meta: con --run search, browse, home o section y la capacidad meta, a tu meta se le pregunta por el primer título de la respuesta que trae ids.imdb o ids.tmdb (como arma Kino la consulta); se lista lo que descarta, y un error o pasarse de 6 s es un problema.

kino.meta y kino.tmdb (Kino 0.9.53)

Las dos funcionan en cualquier función que corra el runner, con los sustitutos del kit (cualquier apiVersion):

KINO_META_FIXTURE=meta.json node sdk/run.mjs . home        # kino.meta responde desde meta.json; sin él, null
KINO_TMDB_KEY=<tu llave de TMDB> node sdk/run.mjs . home   # kino.tmdb le pregunta a TMDB con TU llave donde Kino usa la suya (o "tmdbKey" en sdk/config.json)
KINO_TMDB_FIXTURE=tmdb.json node sdk/run.mjs . search matrix   # kino.tmdb responde sin red desde tmdb.json
  • meta.json asocia "<type>:<idKey>:<valor>" o "<idKey>:<valor>" ("movie:imdb:tt0133093", "tmdb:1399") a una respuesta; responde el primer id de la consulta que tenga entrada, o null (la consulta de TMDB y AniList de Kino y los demás plugins de la persona no existen en Node).
  • tmdb.json asocia "<path>?<params ordenados por nombre, codificados>" o solo "<path>" al cuerpo de TMDB ("/trending/movie/week?language=es-MX"); el archivo hace las veces de TMDB y de una llave, y una ruta que no tenga responde not_found.
  • Tu llave hace las veces de la de Kino, con el límite de la llave de Kino (20 llamadas cada 10 s); el kit no tiene una llave de la persona a la que pasar, así que pasado ese límite lanza rate_limited.
  • Sin llave ni archivo, kino.tmdb lanza no_tmdb_key, como hace una versión de Kino sin llave propia con una persona sin llave, y el runner muestra la frase que Kino mostraría. Tu llave nunca se imprime.
  • La validación, los límites, la caché y los códigos de error son los de la app (kino.meta, kino.tmdb); node sdk/validate.mjs avisa si tu código llama cualquiera de las dos sin typeof kino.<nombre> === "function" (las versiones anteriores de Kino no tienen ninguna). Hay ejemplos de los dos archivos en docs/plugins/fixtures/kino-services/ del repositorio de Kino.

kino.device y kino.seed (Kino 0.9.55)

El kit trae las dos. kino.device es "phone" salvo que pases --device tv (o definas KINO_DEVICE=tv), así corres tu plugin una vez como cada uno. kino.seed no envía nada a ningún lado: aplica el mismo filtro que la app (las claves y límites de kinoSeed en el contrato) y registra qué claves conservaría Kino, nunca sus valores, porque son tokens; sin "telemetry" en tu manifiesto, la línea dice que la app no enviaría nada.

apiVersion 13 (Kino 0.9.74)

El kit conoce apiVersion 13, que Kino soporta desde la 0.9.74 (Novedades): validate.mjs revisa las seis capacidades nuevas (cada una rechazada por debajo de 13, read obligatorio con byteSource e image con imageSource) y el tipo de ajuste qr con su refreshMs. Lo que hace cada una en el kit:

  • kino.ws corre sobre el WebSocket global de Node con las reglas de la app: solo wss://, un host declarado por el puerto 443, sin IP literal ni nombre local, 4 sockets, el tope de tamaño de frame, frames hex/base64 aceptados y rechazados con las mismas palabras de la app. Cambia globalThis.WebSocket por una imitación para probar sin red (un ejemplo).
  • byteSource: run.mjs . resolve acepta una respuesta { source: "plugin", handle, size, mime } con las reglas de la app; node sdk/run.mjs --size <bytes en total> . read <handle> <offset> <length> llama tu read como lo hace el proxy de Kino e imprime la cantidad de bytes, el sha256 y los primeros bytes; askRead(plugin, manifest, stream, offset, length) hace lo mismo desde una prueba (Sockets y bytes del plugin).
  • kino.catalog es el catálogo de la app en memoria, para una corrida: las mismas respuestas y los mismos errores (los dos corren los mismos vectores de prueba compartidos), con el tamaño del archivo estimado en lugar de medido.
  • storageLarge le da a kino.storage los límites de la app: 16 MB, 2 MB por valor y 1.000 llaves.
  • kino.qr.scan necesita una imitación: createKino(manifest, { qrScan: async ({ title }) => "texto" }); sin ella, o con --device tv, falla con unavailable. Revisa de dónde viene la llamada como la app (Códigos QR).
  • imageSource: checkOutput conserva o descarta una referencia como la app, y askImage(plugin, manifest, ref) de sdk/kino-shim.mjs le pide la imagen a tu image como lo hace Kino (Imágenes del plugin); node sdk/run.mjs --out poster.jpg . image <handle> escribe lo que responde.
  • Las operaciones de bytes de kino.crypto (aesIge, aesIgeVerify, modPow, gunzip, convert) dan las respuestas de la app. Dependen de la versión de Kino, no de tu manifiesto, así que el kit ofrece lo que tiene su propio contrato: en tu plugin revisa cada una (typeof kino.crypto.convert === "function").
  • init.mjs --with byteSource,images,catalog,socket (cualquiera de ellas) arma un plugin de apiVersion 13 que declara esas capacidades, con un ejemplo de cada una que funciona y viene comentado (read, image, kino.catalog, kino.ws).

apiVersion 14: pantallas, paneles, trabajos y lo compartido

Disponible con Kino 0.9.74

Disponible desde Kino 0.9.74. El kit lo conoce todo.

Las pantallas, los paneles en modo pantalla, las pestañas que aportas al panel de otro plugin, los trabajos en segundo plano y kino.shared tienen sus propios comandos:

node sdk/validate.mjs <folder>                                    # the manifest, the exports, every consent line, enhancements
node sdk/run.mjs <folder> screen                                  # the tree as Kino reads it (aliases resolved, drops logged)
node sdk/run.mjs --device tv <folder> screen                      # as a TV
node sdk/run.mjs --state '{"inputs":{"q":"dune"}}' <folder> screenEvent search
node sdk/run.mjs --context '{"route":{"name":"categories","params":{},"args":{"from":"categories"}}}' <folder> screen
node sdk/run.mjs <folder> panel <ref>                             # a panel (legacy or screen format)
node sdk/run.mjs --state '{}' --screen <folder> panelAction <ref> <name> press
node sdk/run.mjs --foreign latino:Latino <folder> panel <ref>     # a tab you contribute to another plugin's title
node sdk/run.mjs --device phone <folder> job refresh manual       # one job run, with Kino's caps
node sdk/run.mjs --device tv <folder> screen                      # ...then read what the job shared, as the TV
node sdk/run.mjs <folder> shared                                  # what the simulated phone and TV hold

run.mjs imprime el árbol después de las reglas de Kino (con los nombres anteriores que Kino lee por dentro y los valores por tamaño resueltos en byClass), cada nodo y campo descartado, y los campos de la respuesta; validate.mjs revisa el árbol y los objetos go como la app, y reporta como problema cada bloque de enhancements que Kino descartaría. Las variables de entorno KINO_LIBRARY_FIXTURE, KINO_LIBRARY_REVOKED, KINO_ROOM_REVOKED, KINO_PLAYER_CONTROL_REVOKED, KINO_AI_REPLY, KINO_AI_ERROR y KINO_AI_REVOKED hacen el papel de los datos y las decisiones de la persona. En los archivos de node --test, importa las ayudas del kit (createKino, createKitRoom...) como lo hacen las pruebas de los ejemplos (kino-plugin-news, kino-plugin-watch-party). Los archivos de casos de sdk/test/ (screen-cases.json, room-cases.json, job-cases.json, ai-cases.json, shared-cases.json, player-control-cases.json, panel-foreign-cases.json, qr-origin-cases.json) son los mismos casos que corren las pruebas de la app. Más en Pantallas: probar con el kit.

apiVersion 15: identidad, avisos y tiendas

Llega con Kino 0.9.77. El kit ya revisa y corre todo con las reglas de la app:

  • identity: kino.identity.telegram responde con una cuenta de mentira: KINO_IDENTITY_TG=<id|none>, KINO_IDENTITY_TOKEN, KINO_IDENTITY_AUTHOR y KINO_IDENTITY_REVOKED=1. Solo dentro de una llamada de la persona (screen, screenEvent, panelAction). El kit le da el token a cualquier autor, como una compilación de depuración de Kino. Identidad.
  • notifications: kino.notifications.post y clear guardan en <carpeta>/.kino-notices.json; node sdk/run.mjs . notifications lo imprime y KINO_NOTIFICATIONS_REVOKED=1 simula que la persona la apagó. Avisos en la campanita.
  • pluginStore: node sdk/run.mjs <carpeta> storeSync [--since <ms>] [--state '<json>'], storeList [popular|recent] [categoría] y storeSearch "<q>" [categoría] imprimen la respuesta como la guardaría el índice de Kino y avisan por stderr lo que Kino descartaría. node sdk/init.mjs mi-tienda --store local|live arma una tienda. Tiendas de plugins y Tiendas de ejemplo.
  • kino.library: en una serie vista, season y episode (el último capítulo reproducido, solo si su fuente lo numeró); nunca en una película. Con KINO_LIBRARY_FIXTURE.

apiVersion 16 a 18: kinos, tu mes y temas de la app

  • kino.coins (apiVersion 16): un saldo de mentira con las mismas reglas de la app (la capacidad, el export que llama, 30 llamadas por minuto). KINO_COINS_BALANCE=<n> fija el saldo inicial (5 por defecto; cada give lo baja en uno), KINO_COINS_DISABLED=1 es el interruptor de Kinos apagado por la persona (disabled) y KINO_COINS_REVOKED=1 una aprobación retirada (permission_denied). kino.coins.
  • kino.library.stats (apiVersion 17): se responde desde KINO_LIBRARY_FIXTURE igual que watched y saved; KINO_LIBRARY_REVOKED=1 simula el interruptor apagado. La respuesta enableJob de una pantalla se revisa (run.mjs dice en stderr cuándo Kino la descartaría, por ejemplo por debajo de apiVersion 17).
  • appThemes (apiVersion 18): node sdk/validate.mjs . revisa el formato con el mismo analizador de la app y muestra las advertencias de cada tema para el celular y el TV (appThemes <id> (tv): …; Kino's is used). node sdk/run.mjs --context '{"activeTheme":"<id>"}' . screen dibuja tu pantalla de presentación con un tema activo, y screenEvent <nombre> --trigger tap dice qué hace Kino con un go.useTheme o un go.setExperience en la respuesta. El kit no dibuja colores: revisa el aspecto en Kino. Temas de la app.

apiVersion 20: el protocolo entre plugins

El flujo completo, con ejemplos, está en el protocolo entre plugins. En corto:

  • Plantillas: node sdk/init.mjs mi-proveedor --kind provider (solo provee, una puerta con una llamada y un flujo, su prueba) y node sdk/init.mjs mi-consumidor --kind consumer --repo tu-usuario/nombre --door <puerta> --call <llamada> (un consumidor solo de pantalla, "hosts": []: una pantalla con la puerta de instalación, una sola barra compacta, una ruta de detalle, los códigos de error y un interruptor de flujo, probada contra test/provider: un reemplazo con los mismos nombres de puerta y llamada, para cambiar por una copia del proveedor real). node sdk/init.mjs --help lista las opciones; --host <un host del que la pantalla de verdad descarga> agrega uno, solo si descarga (los hosts del consumidor).
  • Un proveedor solo: node sdk/run.mjs <carpeta del proveedor> proto <puerta>.<llamada> '<json del argumento>' y proto <puerta>.<flujo> ['<json del cursor>'] pasan por las revisiones y los códigos de error de la app. Salida 0 con la respuesta, 1 con ✗ <código>: <mensaje>, 2 para un comando mal escrito.
  • Un consumidor contra la carpeta de un proveedor: node sdk/run.mjs --context '{"installed":{"kinotvapp/kino-plugin-tmdb":true}}' --provider ../kino-plugin-tmdb ./cine-trivia screenEvent play responde cada kino.plugins.call con las exportaciones proto_<puerta>_<llamada> del proveedor, con los tipos, tamaños, códigos de error y límites de ritmo de la app. --provider se puede repetir; sin él, toda llamada se rechaza con provider_missing. Sin installed, un consumidor con puerta de instalación no hace nada.
  • Un flujo: ... screenEvent protocol tmdb.trending consulta el flujo una vez y manda el evento protocol { alias, stream, items }; --cursor '<json>' consulta desde un cursor que el proveedor ya devolvió (prueba los repetidos).
  • Una ruta y un valor escrito: --context '{"installed":{…},"route":{"name":"detail","params":{"id":1}}}' dibuja una ruta empujada; screenEvent search "" '"tomate"' --trigger submit manda el texto de un campo (el valor es la tercera palabra, en JSON).
  • Códigos de error: el kit solo provoca provider_missing (sin --provider) y provider_failed (el proveedor lanza un error); los demás se prueban dibujándolos, --state '{"error":"timeout"}' (qué códigos).
  • ¿Se aceptó una propiedad? El árbol que se imprime no repite cada bandera (dense no sale); un valor equivocado imprime una línea · dropped: (appBar dense "yes" is not true or false, ignored), así que sin líneas dropped se aceptó, y --raw muestra el árbol tal como lo devolvió tu plugin.
  • La puerta de instalación: screen recibe installed con cada entrada de recommends en false; --context '{"installed":{"kinotvapp/kino-plugin-tmdb":true}}' la dibuja como si el proveedor estuviera instalado.
  • Los textos en inglés: --lang en (lo mismo que "lang": "en" en --context). Si no, run.mjs imprime los de español.
  • El manifiesto: node sdk/validate.mjs . revisa provides y consumes, en el nivel principal y dentro de enhancements["20"], igual que la app; falla si una llamada o un flujo declarado no tiene su exportación proto_, y avisa si un repositorio consumido no está en recommends, si un everySeconds está fuera de 30..86.400, si hay un campo providesOnly y si un host es de relleno (example.com, *.example.com, example.org, .test, .invalid, .example; a un consumidor solo de pantalla le dice que no declare ninguno, "hosts": []).
  • El kit atiende una entrada de consumes con el primer proveedor que tiene la puerta (no tiene repositorios, así que nunca revisa tu repo), y no aplica la regla 18+, ni la revisión de secretos sellados, ni el rechazo de llamarse a sí mismo: mira el protocolo entre plugins y Lo que el kit no puede copiar.

apiVersion 22 y 23: progress y el hueco del reproductor

kino.progress (apiVersion 22) guarda sus elementos en memoria durante la ejecución, con las revisiones y los códigos de error de Kino. El hueco del reproductor (apiVersion 23) tiene sus dos comandos, con los mismos cambios de contexto que un panel:

node sdk/run.mjs <carpeta> playerSlot [ref]                         # el cuadro que Kino guarda: orden declarado, refreshMs ajustado
node sdk/run.mjs <carpeta> playerSlotAction <ref> <id del botón>    # qué hace Kino con un toque: { openPanel, player, controlled }
node sdk/run.mjs --bare <carpeta> playerSlot                        # el contexto de un título que Kino no puede compartir (sin kind)
node sdk/run.mjs --live-channel tdt:la1:La 1 <carpeta> playerSlot - # un canal de En vivo

validate.mjs revisa el bloque slot y los dos exports, e imprime la línea roja de un elemento fixed. Mira El hueco del reproductor.

Kino 0.9.88: dejar listo por adelantado, en vivo por reloj

node sdk/run.mjs <carpeta> prepare <ref>     # corre prepare(ref): qué hace Kino con él, o por qué nunca lo llama
node sdk/validate.mjs <carpeta>              # anota qué significan "resolveAhead": true y un prepare exportado, y avisa
  • prepare <ref> corre tu prepare con ese ref e imprime qué hace Kino con él (su respuesta se ignora), o avisa que Kino nunca lo llama (al lado de "resolveAhead": true, catalogOnly o browser, o sin la capacidad resolve); pasados 15 s avisa que Kino deja de esperar ahí.
  • validate.mjs avisa de un resolveAhead que no es true ni false, o que está al lado de catalogOnly o browser, con las palabras que registra la app, y anota qué significa un true que se mantiene. No revisa el resto de la regla: Kino resuelve por adelantado solo con un "fetchHosts": "any" aprobado y video desde cualquier servidor (Dejar listo un título).
  • kino.pluginApiVersion es tu apiVersion efectivo: tu apiVersion o la clave más alta de enhancements que aplicó el kit.
  • clockLive todavía no está modelado: resolve revisa la url normal (En vivo por reloj).

Lo que el kit de Node no reproduce

Kino es la autoridad; el kit solo se le aproxima para que puedas iterar rápido. Antes de publicar, instala el plugin en la app y pruébalo ahí. Las diferencias:

  • kino.html.select lanza un error (usa Jsoup, que solo existe en la app).
  • El lector XMLTV del kit es un recorrido tolerante con expresiones regulares, no el analizador XML de la app. Da la misma respuesta que la app en todas las guías de prueba compartidas, pero ante un XML mal formado a mitad de documento puede conservar más que la app (que se detiene en el primer error y conserva lo que leyó hasta ahí).
  • La trampa del rechazo de Límites y trampas del motor: Node ataja lo que Kino 0.9.49 y anteriores no atajarían.
  • Los globales que a Kino le faltan (setTimeout, fetch, Buffer, ...) tampoco existen en el kit: tu plugin corre en un entorno aislado que solo tiene lo que Kino da (KINO_SDK_NO_SANDBOX=1 lo desactiva para depurar). El URL de Kino no tiene punycode.
  • Las reglas de hosts, de redirecciones y de cantidad de peticiones son las mismas, y las de cookies también hasta donde llega el análisis propio de Node, pero no se rechazan nombres que resuelven a direcciones privadas, los cuerpos siempre se leen como UTF-8, y el tiempo límite de 15 s cubre la espera de la respuesta pero no la descarga.
  • El kit nunca pregunta por un host: uno no declarado falla como host_not_allowed aunque sea durante resolve o episodes, donde la app podría preguntarle a la persona. Tampoco tiene el permiso amplio de video; "streamHosts": "any" sí lo aplica.
  • No se hacen cumplir los límites de tiempo por llamada, el límite de memoria ni los topes de tamaño de peticiones, respuestas y selectores, salvo los 6 s de meta (ahí Kino se rinde sin avisar, así que el kit lo dice).
  • kino.browser.capture y kino.browser.page siempre responden browser_unavailable (Navegador oculto). En el kit kino.browser.captureAll es true, y revisa las opciones de captura de Kino 0.9.54 como la app (invalid_request) antes de responder eso.
  • kino.lang es siempre "es-CO"; el de la app sigue su idioma desde Kino 0.9.54 (kino.lang).
  • No hay comando details: prueba la exportación details (apiVersion 8, Kino 0.9.54) en la página de una película en la app.