Skip to content

Build a plugin with AI

An AI coding assistant (Claude Code, Codex, Gemini CLI, Cursor, GitHub Copilot, Aider…) can write a Kino plugin for you if it reads the rules first, even if you cannot program: you say which source you want and try the result in Kino; the assistant writes the code, tests it with the kit and tells you what to do at each step. This site publishes the rules in the shapes those tools read best:

File What it is
AGENTS.md The instructions for the assistant: its role, what to read, the step-by-step workflow, the hard rules with their exact numbers, a checklist and the usual mistakes. Also in the repository.
llms-full.txt This whole guide as one text file (English), plus AGENTS.md, contract.json and kino.d.ts. Built with the site, so it is always the same version as these pages.
llms.txt The short index, in the llms.txt format.

Want to use a Nuvio scraper?

To add scrapers to Kino you do not need this prompt: Kino installs the scrapers of a Nuvio repository directly, converting them on the device. See Nuvio scrapers.

Want a plugin that finds its links through Nuvio scrapers?

That is a plugin of your own, and an assistant writes it well if it reads Plugins that use Nuvio scrapers (kino.nuvio, Kino 0.9.71). Use the short Nuvio prompt or, in the prompt below, fill in the «Nuvio scrapers» line.

Want to use a Stremio addon?

You do not need this prompt either. In Ajustes ▸ Plugins, "Agregar plugin", choose Stremio and paste the address of the addon's manifest.json: Kino reads it and generates, on the device, a plugin that talks to the addon's server. See Stremio addons.

Want to use a CloudStream plugin?

No prompt needed (Kino 0.9.54). In "Agregar plugin", paste the address of a CloudStream repository, or its short code, and Kino converts the plugins the person picks. One thing to know: it needs an auxiliary app. CloudStream code never runs inside Kino; it runs in a small separate app, the CloudStream complement (an extra APK). The first time, Kino offers to install it ("Instalar complemento"): it downloads it from the same servers as Kino's own updates, checks that it is Kino's copy (package, version, sha256 and signature) and Android asks for permission to install it. The complement has no internet permission: every request goes through Kino. Until it is installed, those plugins say "Necesitas el complemento de CloudStream" with a button to install it. See CloudStream plugins and the complement.

Want a plugin that uses another plugin's data, or offers its own to other plugins?

From Kino 0.9.81 plugins can use each other through Kino: one opens doors, another asks them (a movie trivia that takes its movies from the TMDB plugin, say). An assistant gets it right if it reads The plugin protocol. Use the short protocol prompt.

Before you start

You need five things. All are free except, sometimes, the assistant.

  1. A GitHub account (github.com/signup). Your plugin lives in a public GitHub repository; Kino installs it from there.
  2. Node.js 18 or newer (nodejs.org, the "LTS" version). It runs the test kit. To check, in a terminal: node --version must answer v18 or a higher number.
  3. Git (git-scm.com), to download and upload the repository. Optional but handy: GitHub CLI (gh), with which the assistant can create the repository and set its topic for you (the first time, gh auth login).
  4. An assistant that can use the terminal, that is, one that runs commands and reads what they answer:

    • in the terminal: Claude Code, Codex CLI, Gemini CLI, Aider;
    • in an editor: Cursor, or VS Code with GitHub Copilot in agent mode.

    How to open a terminal: on Windows, Start menu → type "Terminal" (or "PowerShell"); on a Mac, Cmd + Space → type "Terminal"; on Linux, Ctrl + Alt + T. Create an empty folder, go into it and start the assistant there.

    A chat in the browser, with no terminal, works too, but then you copy each command, run it and paste what it answers back into the chat. 5. Kino on a phone or a TV, to try the plugin for real before sharing it.

And one more thing: the right to use the source. A plugin can only reach what the person could watch anyway; do not ask an assistant to get around a paywall, someone else's login or DRM.

The prompt

Copy it (the copy button is at the top right of the block), change what is between <<< and >>> and paste it into your assistant. If you do not know what to put on a line, leave it as it is: the assistant will ask you.

You are going to write a Kino plugin: a public GitHub repository with kino-plugin.json and one
JavaScript ES module (plugin.js) that the Kino app (video, live TV, music and podcasts) runs in a
QuickJS sandbox.

I may not know how to program. Explain each step in plain words, run the commands yourself (tell
me first which one and why), ask me before anything that cannot be undone (deleting, publishing,
pushing to GitHub) and, when I have to do something on GitHub or in Kino, give me the exact clicks.

The plugin's UI (this rule comes first): for any plugin that needs its own screen, configuration,
onboarding, dashboard or panel, build it with Kino's screens UI: apiVersion 14, the "screen" capability with the
screen() and screenEvent() exports, Flutter-style components (Scaffold, AppBar, TabBar, ListTile, Card, Form,
TextField, the "settings" node...), per-size values, the phone and the TV drawn from the same tree. Keep the old
settings form and the legacy panel format only for compatibility. apiVersion 14 arrives with Kino 0.9.74: to stay installable on older Kinos keep your apiVersion and offer the screen through
"enhancements". Put the code in src/ and bundle it to plugin.js with esbuild (generated, committed, checked with
check:built). Validate with node sdk/validate.mjs . and node sdk/run.mjs . screen (also with --device tv). Follow
the component catalogue (https://kinotvapp.github.io/kino-plugins/en/screen-components/, https://kinotvapp.github.io/kino-plugins/en/screen-forms/, https://kinotvapp.github.io/kino-plugins/en/screen-reference/) and the TV focus rules
(https://kinotvapp.github.io/kino-plugins/en/screens/#tv-focus): Kino draws its focus ring only on nodes the person can press; a node the remote must stop on
just to read it gets "canRequestFocus": true.
Every screen of the plugin uses one compact bar: its AppBar sets mergeWithKinoBar: true and dense: true, with a leading
that is a real exit ({ close: true } on the front page, a back elsewhere). The unnamed route is "main", the front page. A Home
row item that opens a screen uses open: { screen: { args } } and the detail is pushed from the open answer, so Back returns
to the front page. A reader uses Image fit: "width", a scroll with zoom and onScroll, and pages with reverse and progress.
If the site's pictures answer only to its own page, each Image takes headers { Referer, User-Agent }, sent only to hosts
in the manifest's hosts and only with an https picture. From Kino 0.9.88 a screen's pictures may also be http on a public
host (IPTV channel logos): send an http picture only when kino.screen.httpImages === true, else an https one or none (the
initials show). On the TV a plugin's button is 40 dp tall with 14 dp each side (Kino 0.9.88): give it padding, height or
minHeight only when it must be bigger. A Scaffold's NavigationBar keeps each destination's scroll when its scrolling node
has its own key. { ui: [{ fullscreen: true }] } (Kino 0.9.84) hides Kino's bar for an immersive canvas: draw your own way
out. To remember where the person stopped, use kino.progress (apiVersion 22, Kino 0.9.83): the
exact place goes in resume (opaque to Kino, at most 1024 bytes), get(id) answers null when there is none, and Kino draws
no row: the plugin builds its own "keep reading" row from list() (https://kinotvapp.github.io/kino-plugins/en/progress/).
For something small that stays on the TV player (a clock, a score, a button that opens my panel), use the player slot
(apiVersion 23, Kino 0.9.83): the "playerSlot" capability, a "slot" block of 1 to 3 elements (text, icon, image,
button; "overlay" with the controls or "fixed", which asks me in red), and both exports playerSlot(context) and
playerSlotAction({ id, context }); context may lack kind, and refreshMs is 2000 to 60000. A text accepts size, weight, color
and background, and any element left and top; offer them as ordinary settings, and Kino ignores what is invalid and keeps the
text readable (https://kinotvapp.github.io/kino-plugins/en/player-slot/#dress).
If the sign-in keeps its token in the page's localStorage (not in a cookie), open the window with kino.visualBrowser.open and
collect.localStorage: ["access_token"] plus doneWhen.localStorage (Kino 0.9.87, no new apiVersion): the answer's
localStorage holds only the keys named, with "done"; an older Kino answers none, so check it, keep the values in kino.storage and
never log them (storeAs covers cookies only; https://kinotvapp.github.io/kino-plugins/en/visual-browser/#rules).
For a look for the whole app (app themes), the manifest's appThemes (apiVersion 18) holds colours, shapes and type; from
apiVersion 26 (Kino 0.9.87) a theme may also paint: surfaces (fill, stroke and glow per element), style.gloss,
layout (a framed hero and a floating rail, TV only), assets with background.image and typography.fontFamily. Never put those keys in
a theme that declares a lower apiVersion, give every asset its exact sha256 and bytes (a picture at most 2 MB), make the theme look
right with each effect off, and keep text readable on every gradient stop (https://kinotvapp.github.io/kino-plugins/en/themes/#level2).
Prefer a Skeleton to a spinner and a bottom sheet with a search field to many chips; a screen has a 600-node budget.
(https://kinotvapp.github.io/kino-plugins/en/screen-components/#one-compact-bar)

Before writing anything:
1. Read https://kinotvapp.github.io/kino-plugins/AGENTS.md completely and follow it as your
   instructions.
2. Read https://kinotvapp.github.io/kino-plugins/llms-full.txt (the whole guide, contract.json and
   kino.d.ts). If you cannot open URLs, tell me and I will paste them.
3. Start from a template, with "Use this template" (never Fork): kinotvapp/kino-plugin-archive if my
   plugin is simple, kinotvapp/kino-plugin-own-server if it needs settings, a session, downloads or
   live channels (its plugin.js and kino-plugin.json, "Tu servidor" 1.5.0, are the complete API
   reference, up to apiVersion 7). The template's sdk/ folder is the Node test kit. If my plugin is
   music or podcasts, also read the "Music and podcasts" section of the contract (apiVersion 8, Kino
   0.9.54: https://kinotvapp.github.io/kino-plugins/en/contract/#music-podcasts) and use
   kinotvapp/kino-plugin-archive-audio as the reference audio plugin.
4. If my plugin cannot turn what it finds into a playable URL itself and instead hands it to another app
   installed on the phone or TV (a "resolver app"), read https://kinotvapp.github.io/kino-plugins/en/resolver/ and
   "Letting another app resolve what you found" in the contract (apiVersion 11, Kino 0.9.66). In that case the
   plugin only declares "externalResolve" and answers { external: { protocol, ref } } from resolve(); it never
   touches the content itself.
5. If I named a Nuvio repository, read https://kinotvapp.github.io/kino-plugins/en/nuvio-plugins/ (kino.nuvio,
   apiVersion 11, Kino 0.9.71) and copy the shape of its complete example.
6. If my plugin is a sync provider (it carries Kino's own sync between my devices through a service: a bot,
   a storage API, a server of mine), read https://kinotvapp.github.io/kino-plugins/en/sync-providers/ first
   (apiVersion 12, Kino 0.9.74). Its references are three public repositories: Sync-Gram
   (https://github.com/kinotvapp/kino-plugin-sync-gram, a Telegram bot of the person's own) for a third-party
   service, Sync Servidor (https://github.com/kinotvapp/kino-plugin-sync-server, a single-file Node
   server) for a server of my own, and Sync-Gram Cuenta
   (https://github.com/kinotvapp/kino-plugin-sync-gram-account, the person's own Telegram account over a
   WebSocket, apiVersion 13: sync.generateKey, a one-shot 2FA password in provision, settingsStatus hide) for
   an account of my own.
7. If my plugin is a store (a source of plugins for Kino's store), or uses identity, the vault or notifications, read
   https://kinotvapp.github.io/kino-plugins/en/plugin-stores/, /en/store-examples/, /en/identity/, /en/vault/ and
   /en/notifications/ first (identity, notifications and pluginStore: apiVersion 15, Kino 0.9.77). The vault is apiVersion 28,
   Kino 0.9.90 and requires identity: one call, const secret = await kino.vault.get(), and Kino reads the plugin's own secret
   (an API base, keys) that you registered in the vault — the plugin never sees the vault's URL and can only read ITS OWN
   secret. Real-life example: https://github.com/kinotvapp/kino-plugin-vault-demo. For a store, start from an example
   store with node sdk/init.mjs my-store --host <host> --store local|live.
8. If my plugin uses another plugin's data, or opens a door for other plugins, read
   https://kinotvapp.github.io/kino-plugins/en/protocol/ first (the plugin protocol: apiVersion 20, Kino
   0.9.81) and copy the patterns of Cine Trivia (https://github.com/kinotvapp/kino-plugin-cine-trivia, a
   consumer with the install gate) and TMDB (https://github.com/kinotvapp/kino-plugin-tmdb, a provider). Start
   from the kit's scaffold: node sdk/init.mjs my-plugin --kind provider, or --kind consumer --repo owner/name
   --door <the real door> --call <a real call> (it writes "hosts": []); its test/provider is a
   stand-in to replace with a copy of the real provider. One-page summary:
   https://kinotvapp.github.io/kino-plugins/en/protocol-quick/.
9. For the Share button (it goes in every plugin, see the rules), read https://kinotvapp.github.io/kino-plugins/en/share/
   and copy Megaplay's shape (its kino-plugin-megaplay repository, src/browse/share.js and
   test/share.test.mjs).

What I want:
- Source: <<< the site or API, e.g. https://example.com >>>
- Content: <<< movies / series / anime / live TV / music / podcasts or audiobooks / a catalog that plays nothing (lists or ratings); language and country >>>
- Access: <<< none / my username and password on the site / an API key of mine (the developer's) that I do not want to publish / the address of a server each person types >>>
- What Kino asks the person when setting it up: <<< nothing / their username and password / their region / their server's address >>>
- Offline downloads: <<< yes / no >>>
- Another app resolves the playable stream (a separate resolver app on the device): <<< no / yes: the app's package name, the protocol name it answers, what "ref" it expects, and how people get it: a GitHub release APK (with its sha256), F-Droid, a Downloader code for TV >>>
- Nuvio scrapers: <<< none / the Nuvio repository (owner/repo) the plugin gets its links from >>>
- Sync provider (the plugin carries Kino's sync between my devices instead of the local network): <<< no / yes: the service, whether it gives each person a long random token, and whether the service may read the synced data >>>
- Name in Kino and a short description: <<< e.g. "Mi fuente": "Películas de …, en español" >>>
- Its own screen (a dashboard, a setup flow, a panel tab...): <<< no / yes: what it shows and what the person does there >>>
- A store (a source of plugins for Kino's store, apiVersion 15): <<< no / yes: local (a list it hands over in the background, from GitHub, my server or a static JSON file) or live (also answers while the person browses: storeList and storeSearch, so what they search reaches my server), the hosts it uses, and the plugins it lists >>>
- Identity or notices (apiVersion 15): <<< no / yes: who needs the person's Telegram pseudonym (only the author keys Kino trusts get the signed token; from Kino 0.9.88 any other plugin gets the pseudonym and, with a challenge, the attestation, and an older Kino refuses it) and what notices to leave in the Home bell >>>
- Other plugins (the plugin protocol, apiVersion 20, Kino 0.9.81): <<< no / it uses the door of another plugin: its repository and door (e.g. kinotvapp/kino-plugin-tmdb, "movies") / it opens a door: what other plugins could ask it >>>
- Files on the person's device (apiVersion 21, Kino 0.9.82): <<< no / yes: what kinds (books, music, videos, pictures, subtitles), one file or a whole folder, and whether it only reads them or plays them >>>
- Remember where the person stopped (apiVersion 22, Kino 0.9.83): <<< no / yes: what the person goes through page by page or chapter by chapter (a manga, a book, a podcast it plays itself), the unit to remember (chapter and page, a position in the book) and what to keep in resume to come back to the exact place (e.g. { cap: 87, pag: 12 }), and whether my plugin shows its own "keep reading" row (Kino draws none) >>>
- Pictures from a site that only answers to its own page (an Image's headers, Kino 0.9.83): <<< no / yes: the site, the Referer it wants (e.g. https://mangasite.example/) and whether it needs a browser User-Agent; its picture hosts go in hosts >>>
- Something always on the TV player (the player slot, apiVersion 23, Kino 0.9.83): <<< no / yes: what it shows (a clock, a score, a logo, a button that opens my panel), whether it stays the whole time (fixed: Kino asks me in red) or only with the controls (overlay), and how often it changes >>>
- Sign-in that keeps its token in the page's localStorage (kino.visualBrowser, Kino 0.9.87): <<< no / yes: the site, the localStorage keys that hold the token (e.g. access_token) and where to keep them (kino.storage) >>>
- A look for the whole app (app themes; painted surfaces from apiVersion 26, Kino 0.9.87): <<< no / yes: the mood (colours, dark or light), whether it needs surfaces (gradient or glossy buttons, glows), a background picture (my own file, at most 2 MB, in the plugin's repository), its own font (TTF or OTF), a framed hero and a floating rail (TV only) >>>
- What each play costs on the source (it decides between resolveAhead and prepare, Kino 0.9.88): <<< nothing / it counts a play / it spends a quota (how many calls an hour per account) / it spends a trial or a free play / it opens a hidden page >>>
- Live channels from a CDN whose segment addresses end in a growing clock number (live by clock, apiVersion 27, Kino 0.9.88): <<< no / yes: a real segment address, the durations of the playlist's #EXTINF lines, and how to get one instant with the segment that began then >>>
- Share to Kino Social (recommended in every plugin): <<< yes, from each title page and from the bar / only from the bar (text only) / no >>>
- Sign the plugin with my own key, so people know every update is mine: <<< yes / no >>>
- My GitHub user: <<< e.g. my-user >>>

Rules you cannot break (the detail and exact numbers are in AGENTS.md):
- Declare in "hosts" every host you know: the API's and the video's, subtitles', audio's, segments'
  and redirects' (*.x does not cover x). If one is missing, Kino asks the person once when a title
  is opened or played; do not rely on it. If the video comes from changing CDNs, use
  "streamHosts": "any" (apiVersion 4; the person approves it at install); for live channels,
  "liveStreamHosts": "any" (apiVersion 3, needs the "channels" capability). If the site or its
  extractors rotate domains and you cannot list them, use "fetchHosts": "any" (apiVersion 9, Kino
  0.9.55; the person approves it in red; https on port 443 only, under a request budget, never the home network) and check kino.fetchAnyHost.
  There is no maximum number of hosts from Kino 0.9.45; Kino 0.9.44 and older refuse more than 20, so
  if you declare more than 20, tell me.
- In kino-plugin.json write "entry": "plugin.js" and "icon": "icon.png", NEVER "./plugin.js": Kino
  0.9.45 and older refuse a leading "./" and the plugin does not install.
- It is neither Node nor a browser: no fetch, setTimeout, Buffer, process, require, crypto or Intl;
  use kino.fetch, kino.sleep, kino.crypto, kino.storage. URL, URLSearchParams, atob, btoa,
  TextEncoder, TextDecoder and console do exist. One file, no import.
- Never throw before the first await of an async function (await first, validate after): Kino 0.9.50
  catches it, but 0.9.49 and older abort the whole call, and people update late.
- Use kino.fetch whenever it can find the video. Only if a server's embed builds the address by
  running its own scripts, use the hidden browser ("browser": true, apiVersion 6; it asks me in red)
  and call kino.browser.capture only inside resolve. Never try to solve or get around a captcha or a
  "verify you are human" check: on blocked, move to the next server. If a title has several servers
  or languages, resolve one and list the others as alternatives { label, ref }.
- Limits: search 15 s, prepare 15 s and the other calls 20 s; 60 requests per call (every redirect hop counts,
  refused ones too) and at most 6 at once; 5 MB bodies; 256 KB of
  kino.storage; 100 search results; Home with 20 rows of 60.
- Errors for the person: kino.error("auth_required" | "not_found" | "geo_blocked" |
  "rate_limited" | "unavailable"). With apiVersion 6 you may add a sentence of your own,
  kino.error(code, detail, { userMessage: "…" }): in Spanish (or in kino.lang's language, see the
  language rule), at most 160 characters, no URL or
  domain, no long numbers, never asking for money, passwords, codes or contact outside Kino, and never
  echoing what the person typed (Kino shows it as "Mensaje de <plugin>: …" only if it passes all its
  rules; a plugin that uses it to ask for money or data breaks the rules and is taken out of the community index).
- Home categories: preferably group the content in Kino's categories
  (https://kinotvapp.github.io/kino-plugins/en/categories/): declare "genre" on each home() row and "genres"
  on each item using ids from that list (peliculas, series, anime, accion, comedia, drama...), also send
  "year" and ids.tmdb, and invent a new category only when nothing fits.
- 18+ content: mark it with adult: true (apiVersion 6; Kino shows it only with the 18+ code
  unlocked). Never try to get around that lock.
- Everything the person reads is in Spanish from Bogotá with tuteo, never voseo, and the texts the
  code builds (row titles, userMessage) are in kino.lang's language: from Kino 0.9.54 kino.lang may be
  "en-US", and then they go in English (before 0.9.54 it is always "es-CO").
- Music and podcasts (apiVersion 8, Kino 0.9.54): kind "music" is an album, a playlist or a track;
  kind "podcast" is a show, an audiobook or a radio program; "artist" is optional (the artist, or the
  host or author). If the plugin declares "episodes", episodes() must answer for every music and
  podcast ref, even a single track; without "episodes", the item's own ref goes to resolve. Below
  apiVersion 8 such items are dropped.
- The person's playlists on your plugin (apiVersion 10, Kino 0.9.65): if the service has the
  person's OWN playlists (their account, not your catalog), you may declare the "playlists"
  capability; its six functions are each independently optional, including playlists() itself. It
  is a contract not yet wired into any Kino screen, so do not present it as something already live
  in the app. Read it at https://kinotvapp.github.io/kino-plugins/en/contract/#playlists before
  using it; most plugins do not need it.
- Another app resolving what you found (apiVersion 11, Kino 0.9.66): when a source cannot be turned into a
  URL by the plugin itself and a separate, independently-installed resolver app does it, declare the
  "externalResolve" capability (and, to name the app, the manifest's "externalResolver") and answer
  { external: { protocol, ref } } from resolve() instead of a url. Kino never interprets the protocol or the
  ref; it asks the person's permission, shows the app's progress and plays what it returns. Use it only when the
  plugin truly cannot produce a url, give it a fallback when possible, and do not promise a resolver app exists.
  Read https://kinotvapp.github.io/kino-plugins/en/resolver/ before using it.
- Sync providers (apiVersion 12, Kino 0.9.74), only if I asked for one: declare the "syncProvider"
  capability (it may be the only one) and export syncPull({ maxBlobBytes }) -> { blob, version } or null,
  syncPush({ maxBlobBytes, blob, expectedVersion }) -> { version } and, optionally, syncStatus(null) ->
  { ready, message? }. The blob is opaque base64 ciphertext made by Kino: store it and give it back byte
  for byte, never decode it. Throw kino.error("conflict", …) when the remote copy changed since
  expectedVersion, and kino.error("auth_required", …) when settings are missing or refused. The manifest
  MUST have a "sync" block with "keySecret" (a provider without it is refused): "keySecret" = the key of a
  "password" setting holding a long random token (never a password a person picks, no "default"); Kino
  derives the sync key from it on each device, so a second device only needs the same settings and no key
  travels, BUT the plugin and its service can read the data and the one consent line says so in red: tell
  me. "provision" (required) = the settings a second device needs, including "keySecret". "maxBlobBytes"
  at most 4194304 (4 MiB; only inside syncPull and syncPush may kino.fetch move that much). If the token
  changes, every other device needs the new one. Never put the token in an
  error, a status line or a log.
- Configuration aids (apiVersion 12): a short "help" setting (what the person needs and where to get it)
  and a "link" setting (an https button, e.g. https://t.me/BotFather). From Kino 0.9.74 an action may
  answer link: { candidate, confirm } (Kino asks "Is this you, <candidate>?" before running the confirm
  action) and setSettings: { key: value } to fill the plugin's own "text" or "select" settings (never a
  "url"; a "password" only from apiVersion 13). The confirm action carries "linkOnly": true, so the person sees one button.
  Setup a TV cannot do (a token pasted on the phone) carries "devices": ["phone"]: the TV receives it with
  "Recibir configuración" ("Receive settings"), sent from the phone with "Enviar configuración".
- apiVersion 13 (Kino 0.9.74; older Kinos refuse it), only if my source needs it: a service that speaks over a WebSocket ("socket", kino.ws, wss:// to
  my declared hosts, frames as hex/base64 strings), video the plugin serves itself ("byteSource":
  resolve answers { source: "plugin", handle, size, mime } and read({ handle, offset, length }) answers
  { bytes: base64 } of exactly that range, built with kino.crypto.convert, never a JavaScript loop over
  the bytes), thousands of records to search ("catalog", kino.catalog), a bigger device-only storage
  ("storageLarge"), a QR on the settings form ("qr" setting) or the phone's scanner from an action
  ("qrScan", kino.qr.scan), a password that must stay on one device such as a 2FA password sent once ("sync": false
  on that password setting; sync.provision may carry it once to a new device, never as keySecret), a sync
  provider next to "socket"/"storageLarge"/"catalog"/"qrScan" with no resolve or search, a key Kino makes
  (sync.generateKey), a form that hides what a step does not need (settingsStatus answering hide: [keys]), pictures only the plugin can fetch ("imageSource" and an image export). Read
  https://kinotvapp.github.io/kino-plugins/en/bytes/, /en/catalog/, /en/images/ and /en/qr/ first; test read
  with node sdk/run.mjs --size <bytes> . read <handle> <offset> <length> and a Node test (askRead or a fake
  WebSocket); feature-detect every kino.crypto byte operation you use (they depend on the Kino version).
- Feature-detect what older Kino lacks: kino.meta and kino.tmdb (Kino 0.9.53) only behind
  `typeof kino.meta === "function"` / `typeof kino.tmdb === "function"`, and the hidden browser's
  captureAll options (Kino 0.9.54) only when `kino.browser.captureAll === true`. kino.device (Kino 0.9.55)
  is "tv" or "phone" and undefined on an older Kino: use it only for what really differs on a TV box and
  treat anything but "tv" as the phone. Add kino.seed(session) (Kino 0.9.55, behind
  `typeof kino.seed === "function"`) ONLY to a plugin whose source hands out anonymous guest sessions and
  blocks regions from logging in: one brand-new session you just proved works, never the person's own, at
  most every few hours, behind a setting the person can turn off. TMDB goes through
  kino.tmdb, never with a key in the code. Never export a helper named "details": from apiVersion 8
  it is a reserved export.
- Nothing secret in the code or the repository. Each person's username and password go in a
  "password" setting. An API key of mine is sealed: "secrets" in the manifest, sealed with
  `node sdk/seal.mjs --repo USER/REPO --name name`, and kino.secret("name") in the code
  (apiVersion 4).
- Downloads are declarative: if the source allows it, add "download" to "capabilities" (apiVersion
  2) and export nothing extra; Kino calls resolve itself when the download runs. Movies and
  episodes are saved from a plain file (mp4, mkv…) or from HLS that is not live; live channels,
  DASH and anything with DRM, never.
- Signing (only if I said yes): "apiVersion": 5 (needs Kino 0.9.45+). Tell me, in plain words, what
  it is for, and walk me through it: `node sdk/seal.mjs --keygen` ONCE (it writes
  kino-author-key.pem), add `*.pem` to .gitignore BEFORE any commit, and tell me to back the key up
  and never share it (if it is lost, everyone who installed the plugin must uninstall and reinstall
  it). Then `node sdk/seal.mjs --sign --repo USER/REPO` AFTER the last change to plugin.js or
  "version" and again after every later change, never commit the .pem. Never print the key's
  contents in the chat.
- apiVersion: the lowest that works (3 for channels, 4 only for secrets, "streamHosts": "any" or a
  "list" setting, 5 only for a signed plugin, 6 only if you use an apiVersion 6 feature: status lines
  and buttons in the settings, a section of its own, colors, telemetry, migrate, request signing,
  userMessage, adult, channels in Home rows; 6 needs Kino 0.9.50 or newer; 7 only for "tracking" or
  "segments", and it needs Kino 0.9.51 or newer; 8 only for "music" or "podcast" items or the details
  export, and it needs Kino 0.9.54 or newer; 9 for the player panel or a hand-written "fetchHosts":
  "any" (Kino 0.9.55); 10 only for "playlists" (Kino 0.9.65); 11 only for "externalResolve" (Kino 0.9.66);
  12 only for "syncProvider", the "sync" block or a "link"/"help" setting (Kino 0.9.74; Kino 0.9.73 and
  older refuse it); 13 only for "socket", "byteSource", "storageLarge", "catalog", "qrScan", "imageSource"
  or a "qr" setting (Kino 0.9.74); 14 for screens and their capabilities (Kino 0.9.74); 15 for "identity",
  "notifications" or "pluginStore" (Kino 0.9.77); 16 for "coins" (Kino 0.9.78); 17 to 20 only for what AGENTS.md
  section 2 lists for them (Kino 0.9.81); 21 for "files" (Kino 0.9.82); 22 for "progress" and 23 for "playerSlot"
  (Kino 0.9.83; to keep older Kinos, the feature goes in "enhancements"); 24 for a drm list or ClearKey (Kino 0.9.85), 25 for a
  subtitle's own text (Kino 0.9.86), 26 for a painted theme (Kino 0.9.87); 27 only for clockLive (Kino 0.9.88), and even then
  keep the base lower and add "enhancements": { "27": {} }). A catalog that plays nothing declares "catalogOnly": true
  (Kino 0.9.54) and still exports a resolve that fails with not_found, for older Kino. A new id of my own (never
  "archive-org").
- Sharing (recommended in EVERY plugin, unless I say no): a "Compartir" button in the plugin's screen (on a title page, with
  the title, and/or in the bar, text only) that opens a sheet with a text I can change and an "Adjuntar el título" switch, and
  sends the text, plus the title when there is one ({ kind: "movie" | "series", tmdb }), to Kino Social's "wall" door with
  kino.plugins.call("social", "share", { text, title, from }). In the manifest:
  "consumes": { "social": { "repo": "kinotvapp/kino-social", "door": "wall", "calls": ["share"] } } and
  "recommends": ["kinotvapp/kino-social"] (apiVersion 20, or inside enhancements["20"] and behind
  typeof kino.plugins === "object"; Kino 0.9.81 and Kino Social 0.9.7). If it answers provider_missing and Kino Social is not
  installed, answer go: { installPlugin: { repo: "kinotvapp/kino-social" } }; without kino.plugins, an "Actualiza Kino" toast.
  Never publish on my behalf: Kino Social only keeps a draft I review and post there, and you tell me so. From Kino 0.9.84
  the plugin can also declare "openFrom": { "routes": [...] } with the routes of its screen that other
  plugins' cards may open (read route.args in the open event and check them)
  (https://kinotvapp.github.io/kino-plugins/en/share/).
- Getting a title ready ahead (Kino 0.9.88, any apiVersion), from my answer about what a play costs: if a resolve counts a
  play or spends a quota, a trial or a free play, never declare "resolveAhead": true; export prepare(ref) instead, which warms
  a session or a token while I read the title page (Kino ignores its answer; 15 s in the background, once per ref every 5
  minutes; it must spend nothing and start no play). "resolveAhead": true only when resolve spends nothing and the plugin has a
  "fetchHosts": "any" and a "streamHosts": "any" I approve (otherwise Kino resolves nothing ahead). Test with
  node sdk/run.mjs . prepare <ref> (https://kinotvapp.github.io/kino-plugins/en/contract/#resolve-ahead).
- Live by clock (apiVersion 27, Kino 0.9.88), only for an open CDN (no DRM, no per-request signature) whose segment addresses
  a media clock names: a live stream returns a url (a real one for an older Kino), mime "application/vnd.apple.mpegurl" and
  clockLive { template with {seg} (and {mc} with mediaCode), grid in ms, anchor { t, s } }; never with drm, signing or
  external; every segment host passes the channel's host rule. Keep the base apiVersion, add "enhancements": { "27": {} } and
  send clockLive only when kino.pluginApiVersion >= 27 (never check kino.apiVersion for it); resolve returns the Stream itself;
  the kit does not model it (https://kinotvapp.github.io/kino-plugins/en/live-channels/#clock-live).
- No "debug": true in a published plugin unless I ask for it: every plugin already has a "Modo debug"
  switch in Kino's Ajustes, and "debug": true only turns it on by default for everyone. "telemetry" only if I agree that the
  plugin's errors reach Kino; log steps and counts, never what the person types.

Work step by step: first explore the source with real requests, then the manifest, then each
function. After each step run `node sdk/validate.mjs .` and `node sdk/run.mjs . <function> …` and
fix everything Kino would drop. Record fixtures with --record and make
`node --test test/plugin.test.mjs` pass offline. Finish with the AGENTS.md checklist, and before
you hand the plugin over run this self-check and tell me the result of each line:
- `node sdk/validate.mjs .` exits 0 with no problems;
- kino-plugin.json: "entry" and "icon" have no leading "./"; "version" raised; apiVersion is the
  lowest that works; no "debug": true unless I asked for it;
- if signing: "signature" is in kino-plugin.json, `validate.mjs` verified it AFTER the last edit, and
  no .pem is tracked (`.gitignore` has *.pem);
- every host (video, subtitles, segments, redirects) is in "hosts" or covered by an "any" field;
- for discovery: the repository is public and not a fork, the topic kino-plugin is set, and the
  manifest has a Spanish "name" and "description";
- if it plays nothing: "catalogOnly": true, and a resolve that fails with not_found for older Kino;
- if it uses Nuvio scrapers: "apiVersion": 11, the "nuvio" capability and "nuvioRepos" (1 to 4), "streamHosts": "any",
  kino.nuvio only inside functions and behind `typeof kino.nuvio === "object"`; the Node kit answers it
  from a fixture (KINO_NUVIO_FIXTURE; if it says `Unknown capability`, my kit is old: update it, do not remove the
  capability), and the real scrapers are only tested in Kino 0.9.71 or newer;
- if it has music or podcasts: "apiVersion": 8, every audio item has kind "music" or "podcast", and
  (with "episodes") episodes() answers every audio ref, even a single track;
- if it is a sync provider: "apiVersion": 12, "syncProvider" declared, syncPull and syncPush exported,
  "sync.maxBlobBytes" at most 4194304, tests that push and pull a 4 MiB blob and throw "conflict",
  "sync.keySecret" and "sync.provision" declared, and you told me in plain words that the plugin and its
  service can read the data;
- if it uses apiVersion 13: read is covered by a Node test
  that checks every range byte for byte, no handle holds a secret, and every socket is closed;
- the Share button: consumes "social" (kinotvapp/kino-social, door "wall", call "share") and the same repository in
  recommends, provider_missing answers go.installPlugin, the text can be changed before sending, the title can be dropped,
  and the final message says the draft waits in Kino Social (nothing is published on its own);
- if it declares "resolveAhead": a resolve spends nothing and the plugin has "fetchHosts" and "streamHosts" "any"; if it
  exports prepare: node sdk/run.mjs . prepare <ref> prints no warning and prepare starts or counts no play;
- if it uses clockLive: the base apiVersion kept with "enhancements": { "27": {} }, a real url beside it for an older Kino, no
  drm, signing or external beside it;
- if it has a player slot: "playerSlot" and the "slot" block together, both exports present, node sdk/run.mjs . playerSlot
  prints the frame with nothing dropped (also with --bare), and node sdk/validate.mjs . passes;
- if it has a screen: every screen's AppBar has mergeWithKinoBar: true and dense: true with a real-exit leading,
  node sdk/run.mjs . screen and --device tv . screen print the tree with nothing dropped, every
  event name you use answers in screenEvent, and, if its apiVersion is below 14, the screen comes through
  "enhancements" and node sdk/validate.mjs . reports no dropped block;
- apiVersion 15 (Kino 0.9.77 or later).
  A store: "capabilities": ["pluginStore"] (it may stand alone) and optionally "pluginStore": { "mode": "local" | "live",
  "name" }. storeSync({ reason, since, state }) answers { full, entries, removed?, state? } and since/state may be
  absent at any time: when Kino loses a store's rows it syncs it again from scratch, so the store must then answer
  its whole list (full: true) and never rely on a saved cursor. A live store (mode "live") also exports storeList({
  category, sort, cursor }) and storeSearch({ q, category, cursor }), 5 s and 20 calls a minute. Each entry has an
  address (owner/repo, owner/repo/path, owner/repo@ref or url:https://...), an id, a name (1 to 60 characters) and
  optional description, categories, icon, popularity, updatedAt, signed/authorKey (hints only); "recommended" is
  ignored outside Kino Plugins. At most 5,000 entries and 4 MB. One plugin per id across all stores: if two repos
  claim an id the one in Kino Plugins' list wins, otherwise one is kept deterministically, and no store may list the
  id kino-plugins. The store only hands over addresses: it never installs anything and never claims to approve a
  plugin; Kino applies its blocklist and the 18+ code, and shows the consent lines (a red one for a live store). The
  people who publish a plugin answer for it; Kino only lists it. The store view has the tabs "De Kino" (Kino Plugins'
  default list), "De la comunidad" (everything else from every store) and "Instalados". Check with node sdk/validate.mjs
  . and node sdk/run.mjs . storeSync (and storeList / storeSearch for a live store) with nothing reported as [dropped by
  Kino]. identity: kino.identity.telegram({ challenge? }) answers { id, token? } only inside a call the person started:
  the token only for the author keys in kinoIdentity.tokenAuthors (any other author gets the id and, with a challenge, the
  attestation from Kino 0.9.88; permission_denied before); never log or show the token; the plugin works with it refused
  (permission_denied). notifications: kino.notifications.post({ id, title, text?, go? }) and clear(id?), 80-character
  titles, 160-character texts, 20 posts an hour, from a screen or the job. library: kino.library.watched() carries
  season and episode on series. All of it declarative, tested with node sdk/run.mjs . notifications and the KINO_IDENTITY_*
  variables.

At the end, walk me through:
1. Publishing it: a public repository (never a fork) with the files at the root; the topic
   kino-plugin and a GitHub description (About → ⚙ → Description and Topics → Save changes, or
   `gh repo edit USER/REPO --add-topic kino-plugin --description "…"`); and a good "name" and
   "description", in Spanish, in kino-plugin.json, because that is what people see in Kino.
2. Installing it in Kino: on a phone, menu ☰ → Plugins → + button; on a TV, Ajustes → Plugins →
   Agregar. Type USER/REPO → Agregar → read the sheet → Instalar (and Configurar if it asks for data).
3. What to try by hand in Kino, and what to do if something fails.

A filled-in example

This is the "What I want" part for a simple public source. Paste it instead of the prompt's if you want to rehearse the whole path before making your own:

What I want:
- Source: https://archive.org, only the film noir collection (https://archive.org/details/Film_Noir)
- Content: movies; in English
- Access: none
- What Kino asks the person when setting it up: nothing
- Offline downloads: yes
- Name in Kino and a short description: "Cine negro": "Películas clásicas de cine negro de archive.org, de dominio público. No pide cuenta."
- My GitHub user: my-user

Short prompt: a plugin with Nuvio scrapers

If all you want is a plugin whose catalogue is yours and whose links are found by the scrapers of a Nuvio repository, this prompt is shorter (the assistant still reads AGENTS.md):

You are going to write a Kino plugin that finds its links with the scrapers of a Nuvio repository.

I may not know how to program: explain every step in plain English, run the commands yourself (tell me
which one and why first) and ask me before anything that cannot be undone.

Read, in this order:
1. https://kinotvapp.github.io/kino-plugins/AGENTS.md (your instructions).
2. https://kinotvapp.github.io/kino-plugins/en/nuvio-plugins/ (kino.nuvio: the manifest, the four
   calls, the limits and a complete example you must follow).
3. https://kinotvapp.github.io/kino-plugins/llms-full.txt (the whole guide, contract.json and kino.d.ts).

What I want:
- Nuvio repository: <<< owner/repo, or the https address of its manifest.json >>>
- Catalogue: <<< movies / series / anime; where it comes from (e.g. TMDB with kino.tmdb) >>>
- Which scrapers to ask first: <<< e.g. the Spanish-speaking ones / anime ones only for animation / the plugin decides >>>
- Name in Kino and a short description: <<< e.g. "Mi todo en uno": "Películas y series, enlaces de Nuvio" >>>
- My GitHub user: <<< e.g. my-user >>>

Rules: "apiVersion": 11, "nuvio" in "capabilities", "nuvioRepos" with that repository, and
"streamHosts": "any". Call kino.nuvio only inside your functions and behind
`typeof kino.nuvio === "object"`. Ask few scrapers at a time (start with 4 to 6), lower timeoutMs so a
hung one does not spend the resolve's 75 s, and remember in kino.storage which ones worked. A scraper
that fails is an entry with ok: false, not an error. Return one Stream with the best copy and the rest
in alternatives. Every text for the person in Bogota Spanish with tuteo (or kino.lang's language).

The Node kit (the current one) knows "nuvio": `node sdk/validate.mjs .` checks nuvioRepos and `node sdk/run.mjs`
answers kino.nuvio from a fixture you write (KINO_NUVIO_FIXTURE; sample at
https://github.com/kinotvapp/kino-plugin-sdk/blob/main/fixtures/nuvio.json), so test it that way. If validate
says `Unknown capability: "nuvio"`, my copy of the kit is old: tell me to copy sdk/, contract.json and
kino.d.ts again from kinotvapp/kino-plugin-sdk (do not remove the capability). When you finish, tell me how to test
the real scrapers by installing the plugin in Kino 0.9.71 or newer, with the exact clicks.

Short prompt: plugins that use each other

For a plugin that uses another plugin's door (a consumer) or opens one for other plugins (a provider). The plugin protocol arrives with Kino 0.9.81: the plugin will only install, or only open its door, on Kino 0.9.81 or newer. Fill in the part that applies and delete the other:

You are going to write a Kino plugin that uses the plugin protocol (apiVersion 20, Kino 0.9.81):
plugins that use each other through Kino.

I may not know how to program: explain every step in plain English, run the commands yourself (tell me
which one and why first) and ask me before anything that cannot be undone.

Read, in this order:
1. https://kinotvapp.github.io/kino-plugins/en/protocol-quick/ (the protocol on one page: shapes, a minimal
   screen, the test commands, the five traps), then https://kinotvapp.github.io/kino-plugins/AGENTS.md (your
   instructions; its contents table at the top gives the line where each part starts; section 4,
   "apiVersion 20: the plugin protocol", is the part that matters most here).
2. https://kinotvapp.github.io/kino-plugins/en/protocol/ (provides, consumes, kino.plugins.call, the types,
   the seven error codes, the limits, streams, the install gate, and the TMDB + Cine Trivia example).
3. https://kinotvapp.github.io/kino-plugins/llms-full.txt (the whole guide, contract.json and kino.d.ts:
   the "protocol" section of contract.json has every number).
Study the two reference plugins before writing anything: https://github.com/kinotvapp/kino-plugin-cine-trivia
(a consumer) and https://github.com/kinotvapp/kino-plugin-tmdb (a provider, TMDB 1.3.0 and later).

What I want:
- Role: <<< consumer (uses another plugin's door) / provider (opens a door for others) / both >>>
- If consumer: the provider's repository and door: <<< e.g. kinotvapp/kino-plugin-tmdb, door "movies" >>>
  and what my plugin does with that data: <<< e.g. a movie quiz / a "random movie tonight" screen >>>
- If provider: what other plugins could ask for: <<< e.g. "a song's lyrics by title and artist", "today's matches" >>>
  and where that data comes from: <<< e.g. kino.tmdb / my site https://example.org/api >>>
- Should my plugin stay installable on older Kinos? <<< yes (use enhancements["20"]) / no (apiVersion 20) >>>
- Name in Kino and a short description: <<< e.g. "Cine Trivia": "Preguntas de cine con películas de TMDB" >>>
- My GitHub user: <<< e.g. my-user >>>

Rules:
- Kino is the only middleman: never import, fetch or copy the other plugin; a consumer only uses
  `await kino.plugins.call(alias, call, arg)` with a "consumes" entry; a provider only answers through
  exports named exactly proto_<door>_<call>(arg) and proto_<door>_<stream>(cursor) -> { items, cursor }.
- Names of doors, calls, streams and aliases: letters and digits, starting with a letter, at most 32. Types
  only from the closed language (string, number, boolean, T?, T[], a door type, an inline object).
- Consumer: list in "consumes" only the calls and streams it uses, put the same repository in "recommends",
  and while installed["owner/name"] is not true draw ONLY an install screen with one button
  { go: { installPlugin: { repo: "owner/name" } } }; never install anything yourself. Every
  kino.plugins.call goes in try/catch and shows a short message for each code (provider_missing,
  not_declared, bad_input, bad_output, rate_limited, timeout, provider_failed); no retry loops, no calls from
  a background job. Arguments never carry tokens, passwords or anything private: they reach the provider.
- Provider: answer only what the door declares, nothing private in answers or thrown errors, never a sealed
  secret; a short "summary" the person understands; once published, a door only grows (new calls,
  optional fields).
- Limits: 64 KB per request and answer, 10 s per call, 30 calls in any 10 s per door, 4 doors per plugin,
  16 calls and 8 streams per door, 8 consumes entries, streams polled every 30 s at least.
- Every text for the person in Spanish (neutral, tuteo, never voseo) and English (text + textEn).
- A screen-only consumer (apiVersion 20, a non-empty "consumes", "capabilities" exactly ["screen"]) declares
  "hosts": [] (an Image needs no host declaration; its own kino.fetch is refused with no host unless it declares
  fetchHosts "any" or a url setting). Any other capability brings back "at least one host": then list only the real
  hosts its kino.fetch reaches. Never example.com or an invented host (validate warns on a placeholder). See
  https://kinotvapp.github.io/kino-plugins/en/protocol/#consumer-hosts. A provides-only plugin (apiVersion 20,
  provides, no capabilities, no settings) may also have "hosts": []; there is no "providesOnly" field.
- Screen trees: a Scaffold whose appBar is { "type": "AppBar", ... }; SingleChildScrollView takes "children"
  (a list), never "child"; buttons are ElevatedButton/TextButton with labelText + labelTextEn and onPressed
  (FilledButton does not exist). Copy the minimal consumer screen of AGENTS.md section 4.

Start from the kit's scaffold, not from a blank file: `node sdk/init.mjs my-plugin --kind provider` or
`node sdk/init.mjs my-plugin --kind consumer --repo owner/name --door <door> --call <call>` (`"hosts": []`)
(`node sdk/init.mjs --help`), replace its stand-in `test/provider` with a copy of the real provider, then copy `sdk/`
without `sdk/test/` and `contract.json` next to it (`kino.d.ts` is optional, only editor typings). Test it offline before anything else:
`node sdk/validate.mjs .` (no ✗, and read every ! line); for a provider
`node sdk/run.mjs . proto <door>.<call> '<json>'` and `node sdk/run.mjs . proto <door>.<stream> ['<cursor>']`;
for a consumer `node sdk/run.mjs --context '{"installed":{"owner/name":true}}' --provider <provider folder> . screen`
(also with false, with --lang en and with --device tv: no "dropped" line on stderr), the same --context and
--provider with `screenEvent <event>`, and `screenEvent protocol <alias>.<stream>` (with --cursor '<json>' to
try repeated items). The kit ignores "repo" (it uses the first provider with the door): check it by hand.
If run.mjs does not know --provider or proto, or init.mjs does not know --kind, tell me how to get a newer kit
instead of working around it. The kit does not check the 18+ rule, sealed secrets in answers nor self-calls:
when you finish, tell me how to try it in Kino 0.9.81 or newer with both plugins installed, then with the
provider switched off and removed, with the exact clicks.

Getting Kino to find your plugin

Installing it by typing its address works from the start. For it to also show up by itself in Kino, in the "De la comunidad" tab of the Plugins screen, the repository must:

  1. be public and not a fork (create it with "Use this template");
  2. have kino-plugin.json at its root, valid for node sdk/validate.mjs ., with a name and a description in Spanish (that is what the card shows);
  3. carry the topic kino-plugin (About → ⚙ → Topics) and, better, a GitHub description;
  4. on Kino 0.9.53 and older, be among the 30 with the most stars on the topic.

From Kino 0.9.54 the app reads the matches 100 at a time, in the order the person picks ("Populares" or "Recientes"), "Cargar más" reads the next 100, and "Buscar en GitHub" finds a plugin by its repository's name and description, so a plugin with no stars is found too. Each device searches again every 12 hours, or when "Actualizar" is tapped. The exact clicks and how to check it: Get listed in Kino.

With Kino 0.9.77 (apiVersion 15) the app no longer searches GitHub by itself: the "De la comunidad" tab of the store view (beside "De Kino" and "Instalados") is filled by Kino Plugins, whose daily index is built from the repositories with the kino-plugin topic; the rules above still apply. There is one plugin per id across stores, and a reload icon ends with a toast ("Se actualizaron N plugins" or "Tus plugins están al día").

Signed plugins

If you want people to know that every update comes from you, ask for a signed plugin ("apiVersion": 5, Kino 0.9.45+): you make a key once, the assistant signs plugin.js with it after every change, and Kino checks the signature at install and at each update. The private key stays on your computer: it must never go to GitHub (*.pem in .gitignore), and you should back it up, because if it is lost, everyone who installed the plugin has to uninstall and reinstall it. It is optional: an unsigned plugin works the same. Read the whole page.

If something fails

Paste the full text the terminal printed into the assistant (not a summary) and say what you expected. Some common cases:

What you see What to do
node: command not found, "node is not recognized…" Node is not installed, or you opened the terminal before installing it: install it and open a new terminal.
✗ kino-plugin.json: … The manifest breaks a rule; the message is the one Kino gives. Ask the assistant to fix it following AGENTS.md.
[dropped by Kino] … Kino would drop those results. Ask which rule of the contract they break, instead of accepting a blind patch.
[host_not_allowed] … A host missing from hosts: have it declared.
El campo "entry" debe ser una ruta relativa a un archivo .js (Kino) or Quita el "./" del campo "entry" (kit) "entry" (or "icon") starts with ./. Write "plugin.js": Kino 0.9.45 and older refuse the ./ (why).
La firma del autor no es válida… The plugin is signed and plugin.js or version changed after signing: run node sdk/seal.mjs --sign --repo owner/repo again.
[timeout] … The source is slow or there are too many requests: have it make fewer requests per call.
Works in the kit but fails in Kino The Node kit is more permissive than the app (what it does not reproduce): missing globals, a throw before the first await (on Kino 0.9.49 and older), kino.html.select. Give the assistant the exact message Kino shows (or a photo of the screen).
Kino says "Configura … en Ajustes ▸ Plugins" The plugin needs data: tap the message's Configurar button, or go to Plugins → Instalados → your plugin → Configurar.
It does not show in "De la comunidad" See Get listed in Kino.

Kino's logs (for someone with a computer connected to the phone with adb): adb logcat -s KinoPlugin shows what the plugin writes with kino.log. Never paste passwords or keys into the chat.

Tips

  • Give the assistant a terminal. The kit only helps if the assistant can run node sdk/validate.mjs . and node sdk/run.mjs … and read what they print.
  • Try it in the app. The Node kit is more permissive than Kino (what it does not reproduce): install the plugin and check that it searches, lists episodes, plays (and downloads, if you declared it) before sharing it.
  • Ask for the reasons. When the kit reports a dropped item, ask the assistant which rule of the contract it broke, instead of accepting a patch.
  • Raise the version on every change. Kino only installs an update whose version is higher (Publishing).
  • Mind the rights. A plugin can only reach what the person could watch anyway; do not ask an assistant to get around a paywall, a login or DRM.