Riferimento comandi CLI

Leggi il record del progetto e il credito residuo.

project show

Nessun parametro.

screenrig project show

data.credit_remaining è un conteggio intero di crediti. Sotto 1000 la busta può mostrare un avviso credits_low. Fino al 1° gennaio 2027 l’uso è gratuito entro limiti ragionevoli, quindi il credito residuo è un contatore intero che un agente può leggere, non un’istruzione di spegnimento.

Imposta il nome che le persone vedono nel selettore progetto della dashboard.

project rename NAME

Leggi il piano del progetto, i flag delle funzionalità indipendenti screens e advertiser e il set di capacità effettive. Un diniego di percorso prevale su una lettura di capacità obsoleta.

project capabilities

Leggi la disponibilità giornaliera degli schermi del progetto su giorni UTC.

project uptime [--day-from YYYY-MM-DD] [--day-to YYYY-MM-DD]

screenrig project uptime
screenrig project uptime --day-from 2026-09-01 --day-to 2026-09-30

Intervallo e predefiniti sono quelli di screen uptime. data.items elenca una riga per ogni giorno UTC, dal più vecchio al più recente: online_s e offline_s sommati sugli schermi con stato registrato quel giorno, availability, coverage (la quota del giorno di quegli schermi con stato registrato) e screens (quanti avevano uno stato registrato). La riga di oggi copre gli intervalli terminati finora; screen list mostra chi è online ora.

Leggi la salute della flotta per ora UTC: schermi che segnalano, caldi, display disconnessi, crash.

project health-trend [--from TIME] [--to TIME]

screenrig project health-trend
screenrig project health-trend --from 7d

data.items elenca la salute della flotta per ora UTC: hour, screens_reporting, hot (temperatura massima pari o superiore a 80 °C), display_disconnected e crashing (3 o più crash in 24 ore). La CLI segue next_cursor fino alla fine e risponde ogni ora con next_cursor null. Le ore seguono i report con un ritardo fino a circa 5 minuti.

Crea, elenca o revoca inviti per membri del progetto e acquirenti di annunci.

invitations create --email ADDRESS[,ADDRESS] [--kind member|ad-buyer]
invitations create --link
    [--screen-id ID] [--slot-id ID] [--policy trusted|review_required]
invitations list [--kind member|ad-buyer] [--status STATUS]
invitations revoke ID

--kind predefinito a member. La consegna email è predefinita e scade dopo sette giorni. --email accetta destinatari separati da virgola, fino a cinquanta per richiesta. --link è solo per membri, richiede esattamente un destinatario previsto, e restituisce un URL di invito valido 24 ore una volta per consegna diretta. Non mettere mai quell’URL in log, note o trascrizioni condivise. Le liste non lo restituiscono mai.

Gli acquirenti di annunci usano solo email e necessitano di uno schermo o ambito slot posseduto (o entrambi). --screen-id e --slot-id accettano ID separati da virgola; --policy seleziona trusted o review_required. I filtri di stato sono queued, sent, issued, accepted, revoked, expired e failed.

screenrig invitations create --email teammate@example.com
screenrig invitations create --kind ad-buyer --email buyer@example.com --screen-id scr_LOBBY --policy review_required

Gli agenti non accettano inviti. La persona invitata apre l’email, accede o crea una passkey, e accetta nel dashboard. La registrazione tramite link verifica prima la loro email. Revocare un invito accettato non annulla un’appartenenza; usa i controlli di appartenenza acquirente per revocare l’accesso pubblicitario.

Segnala se questa installazione possiede una credenziale utilizzabile.

agent status

Nessun parametro.

screenrig agent status

Sola lettura. Non modifica mai lo stato locale o server e non costa nulla. Il risultato include il access della sessione, il suo effective_access e, quando l’impostazione di revisione del progetto o un membro senza approvazione lo mantengono basso, access_limited_by (project o person).

Accedi a questa installazione in un account esistente, con l’approvazione di una persona nel dashboard.

login [--project ID] [--access read|propose|manage] [--name NAME] [--no-wait] [--resume ID]

screenrig login --access read

Stampa l’indirizzo del dashboard e un codice di otto lettere su stderr, poi attende fino a 24 ore. La persona verifica che il codice corrisponda e preme Connetti una volta, senza un secondo prompt passkey dopo un accesso al dashboard nell’ultima ora. La busta riporta status: signed_in, il progetto, l’organizzazione e access. Eseguirlo di nuovo su un’installazione con accesso aggiunge un progetto o eleva da Solo lettura o Proponi progetto a Gestisci. Il rifiuto è login_denied e la scadenza è login_expired.

Termina l’accesso di questa installazione e rimuovi i suoi token.

logout

Nessun parametro.

screenrig logout

Revoca l’accesso sul server, quindi rimuove i token memorizzati e segnala status: signed_out. Un errore che potrebbe non aver raggiunto il server li mantiene, quindi rieseguire è sicuro. Esegui screenrig login per accedere di nuovo.

Apri l’URL ordinario del dashboard. Questo comando non crea un link di accesso, non crea una sessione e non richiede credenziali agente.

dashboard [open]

screenrig dashboard

Il dashboard mostra i progetti della persona dopo l’accesso. La selezione progetto nel browser non cambia il progetto associato a un agente.

Richiedi un’email di reset accesso senza credenziali agente.

dashboard reset-sign-in --email ADDRESS

La conferma non rivela se l’email ha un accesso. Il reset inviato scade dopo un’ora; la persona crea una nuova passkey. Il completamento sostituisce le credenziali di accesso e revoca altre sessioni.

Controlla questa installazione e segnala ogni controllo per nome.

doctor [--repair-config]

screenrig doctor

data.checks nomina ogni controllo e il suo stato: runtime Node, percorso di configurazione risolto e permessi, origine del control-plane e sue rotte di servizio, capacità feedback pubblicizzata, e la toolchain multimediale opzionale (ffmpeg, ffprobe, encoder_libx264, encoder_libx265, encoder_libwebp, cwebp, filter_hdr_tonemap).

Qualsiasi controllo fallito fa uscire doctor con codice non zero, quindi leggi i nomi individuali prima di chiamare l’installazione unhealthy. Una toolchain media mancante interessa solo media upload.

Stampa la versione CLI inclusa e il suo adattatore di protocollo.

version

Nessun parametro.

screenrig version

Esegui prima questo in una sessione. Una busta riuscita dimostra che il launcher ha risolto la CLI inclusa. --version e -V fanno lo stesso da qualsiasi punto della riga di comando.

Elenca i client di servizio di questo progetto, attivi e revocati, con le loro chiavi, ID segreti e utilizzo

service-client list

Nessun parametro.

screenrig service-client list

Non restituisce mai un segreto.

Mostra un cliente del servizio.

service-client show ID

screenrig service-client show scl_ID

Elenca l’kid di ogni chiave e l’css_ di ogni segreto per la rotazione

Crea un client di servizio di proprietà di questo progetto.

service-client create --name NAME [--capability NAME]... [--access read|propose|manage] [--key-file PATH] [--secret-file PATH]

screenrig service-client create --name "Nightly report" --access read --capability reports --key-file screenrig-client.pem

Richiede le autorizzazioni di identità, progetto e amministrazione dell’organizzazione descritte sopra. Al massimo 50 client attivi per organizzazione, conteggiati in tutti i suoi progetti. Una chiave senza il proprio kid è identificata dalla sua impronta RFC 7638.

Registra una seconda chiave pubblica per una rotazione senza interruzioni.

service-client add-key ID --key-file PATH

screenrig service-client add-key scl_ID --key-file new.pem

Un client possiede al massimo due chiavi.

Genera un secondo segreto per una rotazione senza interruzioni.

service-client add-secret ID --secret-file PATH

screenrig service-client add-secret scl_ID --secret-file new-secret

Un client possiede al massimo due segreti. Quello attuale continua a funzionare finché non lo rimuovi.

Rimuovi una chiave; i token emessi con essa smettono di funzionare in pochi secondi.

service-client remove-key ID --kid KID

screenrig service-client remove-key scl_ID --kid KID

Un client mantiene almeno una chiave o un segreto.

Rimuovi un segreto; i token emessi con esso smettono di funzionare in pochi secondi.

service-client remove-secret ID --secret-id css_ID

screenrig service-client remove-secret scl_ID --secret-id css_ID

Revoca permanentemente un client di servizio.

service-client revoke ID --yes

screenrig service-client revoke scl_ID --yes

Elimina le sue chiavi e segreti; i suoi token smettono di funzionare entro pochi secondi. Il record resta per audit.

Genera un’immagine statica presentabile a pagina intera nello store dei contenuti multimediali del progetto.

media generate --prompt TEXT [--aspect-ratio RATIO] [--quality low|medium|high] [--tag TAG]
               [--no-progress]

screenrig media generate --prompt "A 16:9 restaurant menu poster for North Lobby Cafe. Dark walnut, gold type. Title NORTH LOBBY CAFE. Items: Espresso $4, Cortado $4.50, House Blend $3. Footer Open 7am to 7pm. Typeset every line of copy in the image." --aspect-ratio 16:9 --quality high --tag LobbyMenu

Il comando memorizza un WebP lossy nello store multimediale del progetto e restituisce data.media_id (med_…). Non ricaricare i byte. Mai stampare pixel o prompt. L’albero di authoring e il contratto prompt vivono su Compose.

Converti un file locale in byte di consegna, caricalo e attendi che l’oggetto sia pronto.

media upload <file> [--content-type TYPE] [--tag TAG] [--folder ID] [--no-wait] [--poll-ms MS]
             [--timeout MS] [--no-transcode] [--codec h264|hevc] [--max-fps N]
             [--max-edge PIXELS] [--webp-quality 1-100] [--no-progress]
             [--preset signage-1080p30|signage-4k30] [--no-audio]

screenrig media upload ./lobby-welcome-loop.mp4 --tag LobbyLoop

Il video diventa un MP4: profilo High H.264 livello 4.2 per default, o H.265 con --codec hevc, in yuv420p taggato Rec. 709. Una sorgente HDR è mappata a tono Rec. 709. L’audio, se presente nella sorgente, è AAC a 192 kbit/s, 48 kHz, stereo.

Le immagini statiche diventano WebP lossy a qualità 90, mantenendo l’alpha se presente nella sorgente. Una sorgente animata cicla all’infinito. Un WebP che già rispetta il limite di dimensione viene passato senza ricodifica.

L’audio diventa un MP3 per la colonna sonora della playlist. Una sorgente MP3 si carica senza modifiche; sorgenti WAV, AAC, M4A, OGG e FLAC si convertono in MP3 a 128 kb/s, che richiede una build ffmpeg con libmp3lame. Una traccia dura da 1 secondo a 3 ore. playlist init trasforma gli input audio in tracce colonna sonora invece che pagine. L’oggetto pronto è un media audio con durata. Non può essere posizionato su una pagina; nominarlo come colonna sonora audio nella playlist.

L’ID dell’oggetto pronto è data.media_id. Lo stesso valore è data.id e data.operation.result.media_id. Questo ID è ciò che prende un selettore di playlist.

Un nome file con poche informazioni come video.mp4 aggiunge un avviso generic_filename all’involucro. Il caricamento ha comunque successo e la CLI non rinomina mai il file; scegli il nome prima di eseguire il comando.

La conversione esegue ffmpeg e ffprobe da PATH, o dai percorsi assoluti in SCREENRIG_FFMPEG e SCREENRIG_FFPROBE. Le immagini preferiscono il codificatore ffmpeg libwebp e ricadono su cwebp su PATH o SCREENRIG_CWEBP. Esegui doctor prima del primo caricamento di una sessione.

--preset signage-1080p30 limita il lato lungo a 1920, il lato corto a 1080 e la frequenza a 30 fps costanti. signage-4k30 limita il lato lungo a 3840, il lato corto a 2160 e la frequenza a 30 fps costanti. Entrambi funzionano con contenuti orizzontali, verticali e quadrati. --no-audio omette la codifica audio per clip silenziose. Queste opzioni si applicano solo al video.

screenrig media upload ./lobby.mov --preset signage-1080p30 --no-audio

screenrig media upload ./menu.png --folder mfd_01EXAMPLEFOLDER000000000

L’upload arriva alla radice della libreria e si sposta nella cartella una volta pronto. media upload-batch --folder sposta ogni elemento caricato allo stesso modo.

Con accesso Proponi, o quando il progetto richiede revisione per modifiche agent, un nuovo caricamento attende la revisione di una persona prima che un tag, una cartella o un selettore all lo riproduca; vedi Revisioni.

Carica molti file locali da un manifesto, riprendendo da un file di stato richiesto.

media upload-batch <manifest.json> [--state FILE] [--concurrency N] [--tag TAG] [--folder ID]
                   [--poll-ms MS] [--timeout MS] [--no-transcode] [--codec h264|hevc]
                   [--max-fps N] [--max-edge PIXELS] [--webp-quality 1-100] [--no-progress]
                   [--preset signage-1080p30|signage-4k30] [--no-audio]

screenrig media upload-batch ./images.json --state ./upload-state.json

La busta contiene data.items[] in ordine di manifest; ciascuno con path, source_filename, sha256, outcome (accepted o resumed), e media_id. data.failed[] contiene gli elementi non consegnati.

Sostituisce sul posto il file di un media. Il suo ID, le sue playlist e le sue pianificazioni continuano a funzionare.

media replace <id> <file> [--expect-rev REVISION] [--note TEXT] [--content-type TYPE] [--no-wait]
              [--poll-ms MS] [--timeout MS] [--no-transcode] [--codec h264|hevc] [--max-fps N]
              [--max-edge PIXELS] [--webp-quality 1-100] [--no-progress]
              [--preset signage-1080p30|signage-4k30] [--no-audio]

screenrig media replace med_01EXAMPLEIMAGE0000000000 ./menu-v2.png
screenrig media replace med_01EXAMPLEVIDEO0000000000 ./intro.mp4 --expect-rev 3 --note "Spring cut"

Il media mantiene il suo ID, i suoi tag e la sua cartella, così ogni playlist e pianificazione che lo nomina riproduce il nuovo file al manifesto successivo, e anche i selettori per tag, cartella e all lo recepiscono. Nulla viene ripianificato. Il comando esegue gli stessi passaggi di media upload (conversione, limite di byte video del piano, limiti di dimensione, quota di archiviazione, trasferimento firmato) e poi sostituisce invece di aggiungere un nuovo media. Non accetta --tag né --folder.

Per impostazione predefinita il comando attende l’elaborazione. data.media_id e data.id sono l’ID del media, data.version è il numero del nuovo file in media versions e data.revision è la nuova revisione del media. data.warnings, data.operation, data.upload, data.transcode e i tempi sono riportati come per media upload, e l’ID dell’operazione è nella risposta. Con --no-wait, data.operation è l’operazione accettata, e data.version e data.warnings sono assenti.

Un cambio di proporzioni è consentito. La risposta contiene un avviso aspect_ratio_changed e data.warnings[].playlists indica le playlist che usano il media, quindi controlla come appaiono. Un file con gli stessi byte di quello attuale viene rifiutato con resource_conflict (codice di uscita 13).

Ogni file precedente rimane nella cronologia del media e conta nei byte archiviati finché la sua versione non viene eliminata; vedi media versions.

Con accesso Propose, o quando il progetto richiede revisione per le modifiche dell’agente, la sostituzione attende una persona e il comando riesce (codice di uscita 0): data.status è pending_review, data.review_id indica la revisione, l’avviso pending_review fornisce il suo URL e data.next è screenrig reviews show ID. Il media continua a riprodurre il file attuale finché una persona non approva; dille quindi che è in attesa e non ripetere la scrittura. Una sostituzione più recente dello stesso media sostituisce quella in attesa. Vedi Revisioni.

Elenca i file che un media ha avuto, con il file in uso per primo.

media versions <id> [--limit N] [--cursor CURSOR]

screenrig media versions med_01EXAMPLEIMAGE0000000000

data.items ha una voce per ogni file che il media ha avuto: number, current, filename, content_type, sha256, bytes, width, height, duration_ms, codecs, source (upload, replace, sync o restore), note, by (tipo person, agent, client o sync, con ID e nome) e restored_from. Il file in uso viene per primo (current: true), poi gli altri dal più recente. La versione 1 è il primo caricamento; ogni sostituzione, ripristino o modifica della sincronizzazione dei media aggiunge il numero successivo.

Senza --limit e --cursor vengono lette tutte le pagine e data.next_cursor è null. Con uno dei due viene letta una pagina: finché data.next_cursor è una stringa, esegui di nuovo il comando con --cursor impostato su di essa. Basta l’accesso di sola lettura. I byte di una versione precedente restano archiviati e contano nei byte archiviati del progetto finché media version delete non li elimina; non c’è limite al numero di versioni conservate, e i byte archiviati oltre l’archiviazione gratuita del piano sono fatturati come qualsiasi altra archiviazione.

Rimette in uso una versione precedente come nuova versione.

media restore <id> --number N [--expect-rev REVISION] [--note TEXT]

screenrig media restore med_01EXAMPLEIMAGE0000000000 --number 2
screenrig media restore med_01EXAMPLEIMAGE0000000000 --number 2 --expect-rev 5 --note "Back to the winter menu"

Il media mantiene il suo ID e passa a una nuova revisione, e ogni playlist e pianificazione che lo nomina riproduce di nuovo quel file. La versione che copia resta nella cronologia e condivide i suoi byte; la nuova versione conta nei byte archiviati come qualsiasi altra. data.media è il media e data.warnings contiene aspect_ratio_changed, che indica le playlist che usano il media, quando il file ripristinato ha proporzioni diverse.

La versione in uso non può essere ripristinata (resource_conflict, codice di uscita 5) e una versione sconosciuta è not_found (codice di uscita 4). Con accesso Propose, o quando il progetto richiede revisione per le modifiche dell’agente, il ripristino attende una persona e il comando riesce (codice di uscita 0): data.status è pending_review con data.review, l’avviso pending_review fornisce il suo URL e data.next è screenrig reviews show ID. Il media continua a riprodurre il file attuale finché una persona non approva, quindi non ripetere la scrittura.

Elimina una versione precedente e i suoi byte archiviati.

media version delete <id> --number N

screenrig media version delete med_01EXAMPLEIMAGE0000000000 --number 2

Il record della versione scompare e i suoi byte lasciano subito i byte archiviati del progetto. L’oggetto archiviato viene rimosso dopo 24 ore, a meno che un’altra versione o il file in uso contenga lo stesso file. Una versione eliminata non può essere ripristinata. La versione in uso non può essere eliminata e nessuna versione può essere eliminata mentre una sostituzione del media è in attesa di revisione; entrambi i casi sono resource_conflict (codice di uscita 5), e media versions ID mostra quale versione è in uso. Una versione sconosciuta è not_found (codice di uscita 4). L’eliminazione richiede l’accesso Manage: una credenziale Propose viene rifiutata con insufficient_access, e l’eliminazione non viene mai proposta per revisione.

Leggi un oggetto contenuti multimediali, inclusa la sua revisione corrente.

media show <id>

screenrig media show med_01EXAMPLEIMAGE0000000000

Scrivi una resa memorizzata su disco per ispezione. Mai stampare i byte.

media download <id> [--output FILE]

screenrig media download med_01EXAMPLEIMAGE0000000000 --output ./lobby.webp

La busta riporta media_id, path, bytes, sha256, content_type, primitive, filename, opzionale source_filename e width / height. Non contiene mai pixel. Usala per verificare un fermo immagine generato prima che venga mostrato sullo schermo.

Elenca gli oggetti multimediali, filtrabili per tag e tipo primitivo

media list [--tag TAG] [--primitive image|video|audio] [--folder ID|root] [--library]

screenrig media list --tag LobbyLoop --primitive video
screenrig media list --folder mfd_01EXAMPLEFOLDER000000000
screenrig media list --library

Ogni riga contiene folder_id, che non è presente alla radice della libreria.

Modifica o cancella il tag su un oggetto. La sua regola di disponibilità si imposta con media availability.

media update <id> (--tag TAG | --tags TAG1,TAG2 | --clear-tag) [--expect-rev REVISION]

screenrig media update med_01EXAMPLEIMAGE0000000000 --tag LobbyLoop

Con accesso Proponi, o quando il progetto richiede revisione per modifiche agent, il rietichettamento di media approvati risponde a ok con avviso media_review_pending: gli schermi continuano a riprodurlo con i tag approvati finché una persona approva la modifica, e un rifiuto ripristina i tag. La revisione appare in reviews list entro pochi secondi; un rietichettamento che non modifica playlist approvate o in attesa di revisione si applica da solo. Vedi Revisioni.

Imposta o cancella quando i selettori dinamici possono scegliere un file.

media availability <id> (--file FILE | --clear) [--expect-rev REVISION]

screenrig media availability med_01EXAMPLEIMAGE0000000000 --file rule.json

I membri e il comportamento della regola sono descritti in Disponibilità dei media.

Elimina un oggetto media.

media delete <id> [--expect-rev REVISION]

screenrig media delete med_01EXAMPLEIMAGE0000000000

Sposta file e cartelle multimediali in una cartella, o torna alla radice della libreria.

media move <id>... (--folder ID | --root)

screenrig media move med_01EXAMPLEIMAGE0000000000 med_01EXAMPLEVIDEO0000000000 --folder mfd_01EXAMPLEFOLDER000000000
screenrig media move mfd_01EXAMPLEFOLDER000000000 --root

Lo spostamento è una richiesta tutto o niente. Una cartella non può spostarsi dentro se stessa o una cartella al suo interno, e le cartelle si annidano al massimo a 10 livelli. Gli elementi già nella destinazione restano come sono. data.media e data.folders contano ciò che è stato spostato.

Spostare file cambia cosa riproducono i selettori by:folder delle loro vecchie e nuove cartelle, dalla risoluzione del selettore successivo di ogni schermo; spostare una cartella non cambia i file propri di nessuna cartella. Sotto Propose access, o quando il progetto richiede revisione per modifiche agente, ogni file spostato attende la revisione di una persona (reviews list) e le playlist approvate continuano a riprodurlo tramite la cartella con cui è stato approvato; vedi Revisioni.

Elenca le cartelle multimediali del progetto

media folder list [--library]

screenrig media folder list
screenrig media folder list --library

Restituisce tutte le cartelle del progetto, al massimo 1000, ordinate per nome: data.items con id, name, parent_id (null alla radice della libreria) e revision. Costruisci l’albero da parent_id. La cartella di un file è folder_id su media list e media show; è assente alla radice della libreria.

Leggi una cartella contenuti multimediali.

media folder show <id>

screenrig media folder show mfd_01EXAMPLEFOLDER000000000

La busta contiene il name, parent_id e revision della cartella.

Crea una cartella contenuti multimediali nella radice della libreria o all’interno di un’altra cartella.

media folder create --name NAME [--parent ID]

screenrig media folder create --name Menus
screenrig media folder create --name Lunch --parent mfd_01EXAMPLEFOLDER000000000

Un’organizzazione contiene al massimo 1000 cartelle in tutti i suoi progetti, annidate fino a 10 livelli. Una playlist riproduce i file di una cartella con un selettore by:folder.

Rinomina una cartella media o spostala con tutto il contenuto in un’altra cartella.

media folder update <id> [--name NAME] [--parent ID | --root] [--expect-rev REVISION]

screenrig media folder update mfd_01EXAMPLEFOLDER000000000 --name Archive
screenrig media folder update mfd_01EXAMPLEFOLDER000000000 --root

Una cartella non può spostarsi dentro se stessa o in una cartella al suo interno, e uno spostamento deve mantenere ogni cartella entro 10 livelli. Inviare i valori correnti è un’operazione nulla.

Elimina una cartella media. I suoi file e cartelle vengono spostati di un livello verso l’alto.

media folder delete <id> [--expect-rev REVISION]

screenrig media folder delete mfd_01EXAMPLEFOLDER000000000

Elimina solo la cartella. I suoi file e cartelle vengono spostati nel genitore, o nella radice della libreria se non ne ha uno. Un selettore by:folder che la nomina poi non corrisponde a nulla, quindi ripuntare prima quelle playlist.

Aggiungi la tua app Microsoft Entra, oppure una connessione Microsoft del progetto, così una sincronizzazione può leggere una cartella SharePoint o OneDrive for work.

media sync account add microsoft365 --name NAME
    (--tenant-id TENANT --client-id ID --secret-file FILE | --connection-id ID)

screenrig media sync account add microsoft365 --name Contoso --tenant-id contoso.onmicrosoft.com --client-id 0b1d2f3a-4c5e-4f60-8a7b-9c0d1e2f3a4b --secret-file secret.txt
screenrig media sync account add microsoft365 --name Contoso --connection-id pcn_01EXAMPLECONNECTION0000

Nell’interfaccia di amministrazione di Microsoft Entra registra un’app a tenant singolo senza URI di reindirizzamento, aggiungi un segreto client (copia il suo valore, non l’ID del segreto), aggiungi l’autorizzazione dell’applicazione Microsoft Graph Sites.Selected (poi concedi all’app l’accesso in lettura a ogni sito) oppure Files.Read.All, e concedi il consenso dell’amministratore. L’app appartiene a questo progetto. Poi esegui media sync account test.

Aggiungi un account Dropbox e stampa il link monouso che il suo titolare apre, dopo aver effettuato l’accesso a Dropbox, per collegarlo.

media sync account add dropbox --name NAME [--app-key KEY]

screenrig media sync account add dropbox --name "Marketing Dropbox"
screenrig media sync account add dropbox --name "Marketing Dropbox" --app-key YOURAPPKEY

data.authorize_url è il link e data.authorize_expires_at la sua scadenza. La CLI non apre mai un browser: invia il link alla persona titolare dell’account Dropbox, che concede l’accesso in sola lettura (files.metadata.read, files.content.read, account_info.read). Esegui media sync account show finché data.state non è ready (parte come pending_consent), poi media sync create dropbox. La tua app Dropbox deve avere abilitati quei permessi e l’URI di reindirizzamento che l’output stampa.

Aggiungi un account Google Drive, subito pronto, e stampa l’indirizzo dell’account di servizio con cui vengono condivise le cartelle.

media sync account add google-drive --name NAME [--key-file FILE]

screenrig media sync account add google-drive --name "Marketing Drive"
screenrig media sync account add google-drive --name "Marketing Drive" --key-file key.json

data.config.service_account_email è l’indirizzo con cui condividere ogni cartella; basta il ruolo Lettore. Tramite l’account di servizio di screenRIG una cartella si sincronizza solo quando un membro di questo progetto con un’email verificata l’ha condivisa o ne è il proprietario (altrimenti media_sync_sharer_not_member). Con la tua chiave si sincronizza qualsiasi cartella condivisa con l’account di servizio.

Elenca gli account di sincronizzazione dei media di questo progetto con il loro tipo, stato e ultimo test; non viene restituito alcun segreto.

media sync account list

Nessun parametro.

screenrig media sync account list

Ispeziona un account: il suo tenant e ID client, lo stato, il segreto mascherato e l’ultimo test.

media sync account show <id>

screenrig media sync account show msa_01EXAMPLEACCOUNT0000000

Un account Dropbox mostra anche chi lo ha collegato e il suo app_key; un account Google Drive mostra il suo service_account_email.

Rinomina un account, modifica il tenant, l’ID applicazione o il segreto client di un’app Microsoft, oppure sostituisci la chiave propria di un account Google Drive.

media sync account update <id> [--name NAME] [--tenant-id TENANT] [--client-id ID]
    [--secret-file FILE | --key-file FILE] [--expect-rev REVISION]

screenrig media sync account update msa_01EXAMPLEACCOUNT0000000 --secret-file new-secret.txt
screenrig media sync account update msa_01EXAMPLEACCOUNT0000000 --name "Contoso tenant" --expect-rev 2

È richiesta almeno una modifica. Una modifica delle credenziali cancella last_test: testa di nuovo l’account. I segreti client di Entra scadono, quindi sostituisci qui il segreto prima che scada.

Crea un nuovo link monouso per collegare, o ricollegare, un account Dropbox.

media sync account connect <id>

screenrig media sync account connect msa_01EXAMPLEACCOUNT0000000

data.authorize_url e data.authorize_expires_at contengono il link, che sostituisce il precedente. Invialo alla persona titolare dell’account Dropbox. Usalo quando la persona non ha completato l’operazione o l’account è reconnect_required (Dropbox non accetta più la connessione). Un account collegato resta collegato finché il nuovo consenso non è completato, e un altro account Dropbox che accede subentra nella connessione.

Controlla un account: l’accesso e le autorizzazioni Graph di un’app Microsoft, oppure la connessione o la chiave di un account Dropbox o Google Drive.

media sync account test <id>

screenrig media sync account test msa_01EXAMPLEACCOUNT0000000

La risposta viene memorizzata come last_test. Per un’app Microsoft riporta credentials (Microsoft ha emesso un token; un rifiuto contiene il suo codice AADSTS, come AADSTS7000215 per un segreto che è l’ID anziché il valore) e permissions (le autorizzazioni dell’applicazione Graph che il token possiede). Sites.Selected da sola è un avviso: ogni sito richiede ancora la propria concessione, e un link di condivisione richiede Files.Read.All. Il test non valuta la concessione di un sito né una cartella: media sync create legge la cartella che indichi. Un controllo non riuscito è data.ok false con uscita 0.

Elimina un account che nessuna sincronizzazione usa.

media sync account delete <id> [--expect-rev REVISION]

screenrig media sync account delete msa_01EXAMPLEACCOUNT0000000

Finché delle sincronizzazioni usano l’account, la risposta è resource_conflict (uscita 5), che le nomina: eliminale prima.

Sincronizza una cartella SharePoint o OneDrive for work in una cartella media.

media sync create sharepoint --account-id ID --url URL [--folder-id ID] [--every DURATION] [--name NAME]

screenrig media sync create sharepoint --account-id msa_01EXAMPLEACCOUNT0000000 --url https://contoso.sharepoint.com/sites/Marketing/Shared%20Documents/Lobby%20Signs
screenrig media sync create sharepoint --account-id msa_01EXAMPLEACCOUNT0000000 --url "https://contoso.sharepoint.com/:f:/s/Marketing/EabcDEF" --folder-id mfd_01EXAMPLEFOLDER000000000 --every 1h --name "Lobby signs"

Una cartella che Microsoft rifiuta è media_sync_source_refused (uscita 5), con l’autorizzazione da concedere; non viene memorizzato nulla.

Sincronizza una cartella Dropbox in una cartella media.

media sync create dropbox --account-id ID --url URL|PATH [--folder-id ID] [--every DURATION] [--name NAME]

screenrig media sync create dropbox --account-id msa_01EXAMPLEACCOUNT0000000 --url https://www.dropbox.com/home/Marketing/Lobby%20Signs
screenrig media sync create dropbox --account-id msa_01EXAMPLEACCOUNT0000000 --url /Marketing/Lobby --folder-id mfd_01EXAMPLEFOLDER000000000 --every 1h --name "Lobby signs"

Ogni esecuzione riprende dalla posizione salvata da Dropbox nella cartella e legge solo ciò che è cambiato. Una cartella che l’account non può aprire è media_sync_source_refused, e una connessione che Dropbox non accetta più è dropbox_reconnect_required (media sync account connect): entrambe terminano con uscita 5, senza memorizzare nulla.

Sincronizza una cartella Google Drive condivisa con l’account di servizio dell’account in una cartella media.

media sync create google-drive --account-id ID --url URL|ID [--folder-id ID] [--every DURATION] [--name NAME]

screenrig media sync create google-drive --account-id msa_01EXAMPLEACCOUNT0000000 --url https://drive.google.com/drive/folders/1AbCdEfGhIjKlMnOpQrStUvWxYz --folder-id mfd_01EXAMPLEFOLDER000000000 --every 1h
screenrig media sync create google-drive --account-id msa_01EXAMPLEACCOUNT0000000 --url 1AbCdEfGhIjKlMnOpQrStUvWxYz

Tramite l’account di servizio di screenRIG la cartella si sincronizza solo quando un membro di questo progetto con un’email verificata l’ha condivisa o ne è il proprietario (media_sync_sharer_not_member, uscita 3, nulla viene memorizzato). Ogni esecuzione lo verifica di nuovo, e una cartella che perde un tale condivisore ferma la sincronizzazione nello stato error con i suoi media conservati: condividila di nuovo dall’account Google di un membro, poi esegui media sync update ID --resume. I file di Google Documenti, Fogli e Presentazioni vengono saltati come unsupported_type. Una cartella che l’indirizzo non può aprire è media_sync_source_refused (uscita 5): condividila con l’account di servizio.

Elenca le sincronizzazioni dei media di questo progetto con la loro cartella media, cadenza, stato e stato dell’ultima esecuzione.

media sync list

Nessun parametro.

screenrig media sync list

Ispeziona una sincronizzazione e il riepilogo della sua ultima esecuzione.

media sync show <id>

screenrig media sync show msy_01EXAMPLESYNC000000000

data.last_run contiene status (ok, partial o error), added, updated, removed, pending_delete (file rimossi ancora in uso su uno schermo, in attesa nella cartella Removed) e skipped con il motivo di ogni file (unsupported_type, too_large, storage, subfolder, download_failed, unreadable, in_use); un’esecuzione non riuscita contiene error con un code e un detail che indicano la correzione. data.source aggiunge path per Dropbox e shared_by per Google Drive.

Una sincronizzazione nello stato error va riparata. La sua cartella media è stata eliminata: indirizzala a un’altra con media sync update --folder-id. La sua cartella di origine è stata eliminata o spostata: elimina la sincronizzazione e creane una nuova. Per Google Drive tramite l’account di servizio di screenRIG, la cartella ha perso il suo condivisore verificato (sharer_not_member): condividila di nuovo dall’account Google di un membro del progetto, poi media sync update ID --resume. Un’esecuzione Dropbox fallisce con reconnect_required quando Dropbox smette di accettare la connessione (media sync account connect).

Modifica il nome, la cadenza o la cartella media di una sincronizzazione, oppure mettila in pausa e riprendila.

media sync update <id> [--name NAME] [--every DURATION] [--folder-id ID]
    [--pause | --resume] [--expect-rev REVISION]

screenrig media sync update msy_01EXAMPLESYNC000000000 --every 1h
screenrig media sync update msy_01EXAMPLESYNC000000000 --pause
screenrig media sync update msy_01EXAMPLESYNC000000000 --folder-id mfd_01EXAMPLEFOLDER000000000 --expect-rev 3

È richiesta almeno una modifica.

Esegui subito una sincronizzazione invece di attendere il suo prossimo orario.

media sync run <id>

screenrig media sync run msy_01EXAMPLESYNC000000000

La sincronizzazione viene eseguita entro circa 30 secondi, e media sync show mostra poi la sua ultima esecuzione. Una sincronizzazione in pausa deve prima essere ripresa.

Ferma una sincronizzazione; i suoi media e la cartella restano.

media sync delete <id> [--expect-rev REVISION]

screenrig media sync delete msy_01EXAMPLESYNC000000000

La sincronizzazione dimentica quale file di origine è diventato quale media. I media importati e la cartella media restano, e nulla viene rimosso.

Impacchetta una cartella statica in un archivio deterministico senza caricarla.

app pack <directory> [--output FILE]

screenrig app pack ./lobby-board --output ./lobby-board.tgz

La busta riporta sha256, compressed_bytes, expanded_bytes, file_count, la lista delle voci e se il runtime SDK è stato iniettato. app upload contiene la cartella stessa, quindi usa questo comando solo se vuoi ispezionare prima l’archivio.

Le applicazioni funzionano sotto una content security policy che blocca il codice inline. Il packing sposta gli stili e script inline in file sotto _screenrig/inline/ e li collega. I gestori di eventi inline come onclick= e URL javascript: non possono essere spostati; il packing li rifiuta e indica file e riga.

Impacchetta una cartella, pubblicala come nuova release dell’applicazione e attendi il successo della pubblicazione.

app upload <directory> [--name NAME] [--no-wait] [--poll-ms MS] [--timeout MS]

screenrig app upload ./lobby-board --name "Lobby board"

Leggi tre campi: data.operation.state è succeeded, data.application.release_id è l’ID rel_ un primitivo application pin, e data.application.id è l’ID app_ che i comandi kv usano. Un’operazione riuscita, non un ID di rilascio da solo, indica che il rilascio è utilizzabile.

Ogni app upload crea una nuova applicazione e una prima release immutabile. Per pubblicare una release successiva della stessa app, usa app update. Una playlist continua a servire la release già fissata finché non modifichi quel primitivo.

Pubblica una nuova versione di un'applicazione esistente, preservando identità, nome e K/V dell'applicazione.

app update <id> <directory> [--expect-rev REVISION] [--no-wait] [--poll-ms MS]

screenrig app update app_01EXAMPLEAPP00000000000 ./lobby-board

Attendere data.operation.state: "succeeded", quindi usare playlist replace-release per rivedere la pagina esatta, il primitivo, la nuova versione e gli schermi interessati. Applicare con il token di impatto restituito e una facoltativa protezione di revisione come descritto nel flusso di lavoro della playlist. I pin esistenti della playlist rimangono invariati fino all’applicazione. In caso di conflitto di revisione, leggere nuovamente l’app prima di decidere se riprovare; non creare un’applicazione sostitutiva solo per bypassare il conflitto.

Elenca le applicazioni del progetto

app list

Nessun parametro.

screenrig app list

Leggi un’applicazione.

app show <id>

screenrig app show app_01EXAMPLEAPP00000000000

latest_ready_release è assente fino a quando una prima pubblicazione non raggiunge lo stato pronto. Lo stato di pubblicazione vive sull’operazione e sulla release, non sull’app.

Elimina un’app e tutte le sue release.

app delete <id> [--expect-rev REVISION]

screenrig app delete app_01EXAMPLEAPP00000000000

Non esiste un’eliminazione per release. Mentre uno schermo mostra una delle release dell’applicazione, l’eliminazione risponde application_in_use: assegna prima altri contenuti a quegli schermi. L’eliminazione non controlla playlist che fissano una release senza mostrarla, quindi aggiorna o elimina anche quelle playlist.

Elenca le chiavi archiviate per un’applicazione

kv list --app-id ID

screenrig kv list --app-id app_01EXAMPLEAPP00000000000

Leggi una chiave.

kv get --app-id ID <key>

screenrig kv get --app-id app_01EXAMPLEAPP00000000000 menu

Scrivi una chiave da JSON, un file o byte base64.

kv set --app-id ID <key> --json-value JSON [--expect-rev REVISION]
kv set --app-id ID <key> --file FILE [--content-type TYPE] [--expect-rev REVISION]
kv set --app-id ID <key> --value-base64 BASE64 [--content-type TYPE] [--expect-rev REVISION]

screenrig kv set --app-id app_01EXAMPLEAPP00000000000 menu --json-value '{"soup":"lentil"}'

Elimina una chiave.

kv delete --app-id ID <key> [--expect-rev REVISION]

screenrig kv delete --app-id app_01EXAMPLEAPP00000000000 menu

Crea un webhook che scrive una chiave e ricevi il suo URL e segreto una sola volta.

kv webhook create <key> --app-id ID [--description TEXT]

screenrig kv webhook create menu --app-id app_01EXAMPLEAPP00000000000 --description "Point of sale menu feed"

La busta è il webhook: data.id (kvw_…), data.key, data.url (https://api.screenrig.ai/api/applications/<app_id>/kv-webhooks/<id>/write) e data.secret (srkw_…). Inserisci URL e segreto nel sistema di invio ora. Nessun comando successivo mostra di nuovo questo segreto.

Elenca i webhook di un’applicazione, dal più vecchio

kv webhook list --app-id ID

screenrig kv webhook list --app-id app_01EXAMPLEAPP00000000000

Ogni elemento ha id, key, description, url, created_at e, una volta scritto, last_used_at. Una lista non contiene mai un segreto.

Elimina un webhook. Il suo URL smette di funzionare immediatamente e la chiave mantiene il suo valore.

kv webhook delete <webhook_id> --app-id ID

screenrig kv webhook delete kvw_01EXAMPLEWEBHOOK00000 --app-id app_01EXAMPLEAPP00000000000

Sostituisci il segreto di un webhook e ricevi quello nuovo una volta sola.

kv webhook rotate-secret <webhook_id> --app-id ID

screenrig kv webhook rotate-secret kvw_01EXAMPLEWEBHOOK00000 --app-id app_01EXAMPLEAPP00000000000

La busta contiene il nuovo segreto in data.secret. Il vecchio segreto smette di funzionare immediatamente, quindi inserisci il nuovo nel sistema di invio.

Modifica un webhook di scheda: descrizione, mappatura, stato di attivazione o firma.

kv webhook update <webhook_id> --card CARD_ID [--description TEXT] [--map FILE|-] [--clear-map]
                   [--enable|--disable] [--signing|--no-signing]

screenrig kv webhook update kvw_01EXAMPLEWEBHOOK00000 --card crd_01EXAMPLEBOARD0000000000 --map alert-map.json

La busta è il webhook. data.signing_secret compare una sola volta, nella risposta che ha attivato la firma.

Leggi il registro delle consegne di un webhook di scheda, dal più recente, degli ultimi sette giorni.

kv webhook deliveries <webhook_id> --card CARD_ID [--limit N]

screenrig kv webhook deliveries kvw_01EXAMPLEWEBHOOK00000 --card crd_01EXAMPLEBOARD0000000000

Ogni voce ha at, outcome (written, unchanged, refused, invalid o handshake), reason (per esempio credentials, signature, disabled, body, mapping, card_data_invalid o rate_limited), detail, status, bytes, revision e request_id. Non viene memorizzato alcun corpo, intestazione o credenziale, e un invio a un indirizzo sbagliato non lascia alcuna riga.

Prepara una playlist a schermo intero modificabile da file multimediali locali, ID media pronti, ID release app o URL HTTP o HTTPS.

playlist init <inputs...> --name NAME --output FILE [--overwrite] [--screen-id ID]
              [--target-width PX --target-height PX] [--duration-ms MS] [--fit contain|cover|fill]
              [--no-transcode] [--no-progress] [--poll-ms MS]

screenrig playlist init med_POSTER med_VIDEO --name "Lobby loop" --screen-id scr_LOBBY --output lobby.json

La preparazione scrive il documento locale e può caricare contenuti multimediali; non crea una playlist remota né assegna uno schermo. Ispeziona il documento, poi screen publish. Vedi Prepara, pubblica e modifica playlist.

Valida un documento playlist localmente prima di creare o aggiornare. Nessuna rete.

playlist validate <file>

screenrig playlist validate ./lobby-loop.json

Gli errori indicano percorsi JSON esatti. Un pass significa che la forma locale e la semantica cross-field sono valide; autorizzazione, prontezza media, conteggi selettore dinamico, durate e disponibilità remota richiedono ancora controlli server. Create e update eseguono questo controllo prima della scrittura. Il risultato include anche segnalazioni di geometria lint che non fanno fallire il controllo: motion_overuse, collision, safe_margin e adjacent_repeat. Per vedere come appare una pagina, pubblicala ed esegui screen screenshot.

Crea una playlist da un documento JSON, da un modello o dal modello integrato Avviso urgente.

playlist create [file] [--from-template ID --name NAME [--set NAME=VALUE...] [--dry-run]] [--starter KEY [--name NAME]] [--format-region REGION --format-orientation ORIENTATION] [--note TEXT]

screenrig playlist create ./lobby-loop.json

screenrig playlist create --from-template pl_01EXAMPLETEMPLATE00000 --name "Monday notice" --set headline="Open late"

data.id della busta è l'id pl_ che accetta screen assign. Quando la modifica attende la revisione, data è {status: pending_review, review, playlist}: la playlist esiste con approved_revision: 0 e nessuno schermo può mostrarla finché una persona non approva (playlist_not_approved). Un modello è una playlist che dichiara fields; non viene mai mostrato su uno schermo (playlist_is_template), e una playlist creata da esso è una playlist normale da assegnare, pianificare e rivedere.

Sostituisci un documento playlist.

playlist update <id> <file> [--format-region REGION --format-orientation ORIENTATION] [--expect-rev REVISION] [--note TEXT]

screenrig playlist update pl_01EXAMPLEPLAYLIST000000 ./lobby-loop.json

Quando la modifica attende la revisione, la playlist live continua a suonare senza cambiamenti finché una persona non approva la proposta.

Leggi una playlist, inclusa la sua revisione corrente.

playlist show <id>

screenrig playlist show pl_01EXAMPLEPLAYLIST000000

Restituisce la versione live. approved_revision è 0 per una playlist che nessuna persona ha ancora approvato, e approval nomina la revisione aperta mentre un cambiamento attende; reviews show ID restituisce la proposta.

Elenca le playlist del progetto

playlist list [--templates] [--library]

screenrig playlist list --templates
screenrig playlist list --library

Mostra i campi di un modello o i valori di una copia, oppure cambia i valori e aggiorna la copia.

playlist fields <id> [--set NAME=VALUE...] [--clear NAME...] [--refresh] [--expect-rev REVISION] [--note TEXT]

screenrig playlist fields pl_01EXAMPLECOPY00000000 --set headline="Closed today"

Senza opzioni mostra i campi di un modello e quante playlist sono state create da esso, oppure i valori di una copia, la revisione del modello da cui è stata creata e se il modello ne ha una più recente. Ogni modifica, e --refresh da solo, ricostruisce le pagine della copia dalla revisione attuale del modello, ed è così che una modifica del marchio fatta sul modello raggiunge le copie esistenti; nulla viene inviato automaticamente. I valori vengono verificati come in una creazione. Con l'accesso Propose, una modifica diventa una revisione.

Elenca le playlist create da un modello e la revisione del modello da cui è stata creata ciascuna.

playlist instances <id>

screenrig playlist instances pl_01EXAMPLETEMPLATE00000

outdated indica una playlist creata da una revisione precedente del modello; playlist fields ID --refresh la aggiorna.

Elenca le revisioni di una playlist, dalla più recente.

playlist revisions <id> [--after CURSOR]

screenrig playlist revisions pl_01EXAMPLEPLAYLIST000000

Ogni revisione indica cosa l'ha creata (created, edited, promoted con la revisione copiata, oppure baseline, la revisione che la playlist aveva quando è iniziata la sua cronologia), chi l'ha fatta, quando, quante pagine contiene e se è quella corrente. Una pagina contiene 50 revisioni; next_cursor legge la successiva.

Leggi una revisione e la playlist com'era in quella revisione.

playlist revision show <id> --revision N

screenrig playlist revision show pl_01EXAMPLEPLAYLIST000000 --revision 3

Rendi di nuovo corrente una revisione precedente copiandola come nuova revisione.

playlist promote <id> --revision N --expect-rev CURRENT

screenrig playlist promote pl_01EXAMPLEPLAYLIST000000 --revision 3 --expect-rev 9

Le pagine, la colonna sonora e il formato della revisione diventano la revisione successiva. Il nome resta invariato, le revisioni precedenti restano nell'elenco e ogni schermo che mostra la playlist si aggiorna. La promozione richiede una credenziale che pubblica dal vivo; una le cui modifiche attendono una revisione riceve forbidden. Una revisione il cui contenuto è già quello corrente non cambia nulla.

Elimina una playlist.

playlist delete <id> [--expect-rev REVISION]

screenrig playlist delete pl_01EXAMPLEPLAYLIST000000

Esporta file di immagini e video, audio della colonna sonora e URL iframe come bundle di playlist portatile.

playlist export <id> --output DIRECTORY [--skip-applications]

screenrig playlist export pl_01EXAMPLEPLAYLIST000000 --output ./lobby-bundle

Il bundle contiene un manifest, il documento della playlist e file di immagini, video e audio della colonna sonora indirizzati in base al contenuto. I selettori dinamici all, tag e folder vengono fissati su ID esatti, gli URL iframe vengono conservati e i commenti vengono esclusi.

Le schede, gli stream e le pagine adslot interrompono l’esportazione prima del download dei media. Anche le applicazioni la interrompono per impostazione predefinita; --skip-applications rimuove le primitive applicative e le pagine vuote o controllate da un’applicazione, indicando gli ID delle primitive e delle pagine saltate. Deve rimanere almeno una pagina. Le schede, gli stream e le pagine adslot interrompono l’esportazione anche con questa opzione.

Per ottenere un documento modificabile che conservi i riferimenti a schede e applicazioni, usa screenrig playlist show pl_01EXAMPLEPLAYLIST000000 --output playlist.json. Il documento usa le risorse esistenti dello stesso progetto.

Crea una playlist da una directory bundle o aggiorna una esistente da essa.

playlist import <directory> [--name NAME] [--update ID [--expect-rev REVISION] [--note TEXT]]

screenrig playlist import ./lobby-bundle
screenrig playlist import ./lobby-bundle --name "Lobby loop (copy)"

I nomi visualizzati delle playlist possono ripetersi. L’importazione crea una playlist separata anche quando il nome corrisponde; usa --update con un ID per sostituire una playlist esistente.

L’importazione convalida l’intero bundle localmente prima che tocchi il progetto: manifest, documento, percorsi, tipi di media, lunghezze e hash. I media esistenti sono riutilizzati se corrispondono esattamente per nome file, tipo media, lunghezza byte, hash e tag; il resto viene caricato senza conversione, e la playlist è scritta solo dopo che ogni oggetto è pronto.

L’importazione non elimina né pota media remoti. Se un passaggio successivo fallisce dopo l’inizio di un caricamento, l’errore elenca gli oggetti confermati pronti e indica se la scrittura della playlist è iniziata. Ritentare lo stesso bundle riutilizza quegli oggetti.

Associa un Player con il codice mostrato sul suo schermo.

screenrig screen pair "$PAIRING_CODE" --name "Lobby"

Elenca gli schermi. Gli schermi archiviati sono esclusi a meno che non vengano richiesti

screen list [--state archived] [--tag TAG] [--folder ID|root]

screenrig screen list --tag Lobby
screenrig screen list --folder sfd_01EXAMPLEFOLDER000000000

Ogni riga contiene il tags dello schermo. Con --human, la tabella aggiunge una colonna TAGS quando almeno uno degli schermi elencati ha tag.

Leggi uno schermo, inclusi revisione, assegnazione e stato online.

screen show <id>

screenrig screen show scr_01EXAMPLESCREEN00000000

tags elenca i tag della flotta dello schermo. effective_playlist, takeover e playlist_schedule riportano cosa riproduce lo schermo e perché; vedi Programmazioni e takeover. health e le capacità host del Player sono in Salute e alimentazione del dispositivo. online è vero mentre un Player è connesso, inclusa una breve finestra di riconnessione. last_online_at e last_ip opzionali appaiono dopo la prima connessione. observation opzionale riporta le superfici dipinte da un Player: id, width, height, pixel_ratio e presentation. Tutti questi sono di sola lettura; screen update non può inviarli, e uno schermo archiviato restituisce comunque la sua riga.

commands elenca gli ultimi 10 riavvii, ricaricamenti, svuotamenti della cache, riavvii dell'app e aggiornamenti dello schermo, dal più vecchio, ciascuno con il suo type, il suo state (queued, sent, done, failed, expired, cancelled o superseded), il suo source (schedule per un riavvio emesso da una programmazione dei riavvii; assente per uno richiesto da una persona), il suo expires_at e quando è stato inviato o completato. reboot_schedule e next_reboot_at riportano la programmazione dei riavvii dello schermo e l'inizio della sua prossima finestra di riavvio. Uno svuotamento della cache, un riavvio dell'app o un aggiornamento concluso dal Player contiene anche il suo cause e un breve detail, che --human stampa come colonna CAUSE e come riga sotto la tabella. suspension contiene message e since di uno schermo sospeso. Uno schermo archiviato da screen replace riporta replaced_by, lo schermo a cui è passato il suo dispositivo. Con --human, screen show li stampa tutti.

last_outage riporta l’ultima interruzione dello schermo: offline_since, back_at e duration_s e, quando un report di salute la determina, una likely_cause tra device_restart, app_crash, app_restart, network o platform; è assente quando screenRIG non riesce a determinarla. Un riavvio viene stabilito al ritorno dello schermo, mentre una causa di rete o di screenRIG attende il successivo report di salute del Player, che può richiedere fino a quindici minuti. glass contiene i verdetti che screenRIG ha tratto dai report di riproduzione e dagli screenshot dello schermo. Con --human, screen show stampa Last outage e Likely cause, e Playlist stalled, Blank screen o Frozen picture per un verdetto che ha trovato un problema; Notifiche dice cosa i verdetti lasciano fuori.

Modifica nome schermo, assegnazione playlist o fuso orario in una sola chiamata.

screen update <id> [--name NAME] [--playlist-id ID] [--timezone ZONE] [--expect-rev REVISION]

screenrig screen update scr_01EXAMPLESCREEN00000000 --name "Lobby"

In revisione, una modifica solo a --playlist-id è proposta come screen assign; una sessione Proponi non può modificare gli altri campi.

Crea una nuova playlist da un file preparato e assegnala a uno schermo.

screen publish <id> <file> [--expect-rev REVISION] [--note TEXT]

screenrig screen publish scr_LOBBY lobby.json

Questo crea una nuova playlist e la assegna. Non aggiorna una playlist esistente per nome. Controlla prima il documento preparato. Ripeti l’input identico per riprendere un errore ambiguo. La lettura dell’assegnazione non prova la riproduzione; richiedi uno screenshot separatamente. In revisione restituisce stage: pending_review con entrambe le revisioni. Vedi Prepara, pubblica e modifica playlist.

Indirizza uno schermo, o una flotta di schermi, a una playlist.

screen assign (<id>... | --tag TAG) --playlist-id ID [--expect-rev REVISION] [--note TEXT]

screenrig screen assign scr_01EXAMPLESCREEN00000000 --playlist-id pl_01EXAMPLEPLAYLIST000000
screenrig screen assign --tag Lobby --playlist-id pl_01EXAMPLEPLAYLIST000000

Se la playlist programma qualsiasi pagina e lo schermo non ha fuso orario, il CLI rifiuta prima di inviare qualsiasi cosa e indica il comando screen set-timezone da eseguire. Nessuna revisione è consumata da quel rifiuto. In una flotta, ogni schermo applica quella regola da solo: uno schermo senza fuso orario fallisce nel suo risultato e gli altri sono assegnati.

Per pubblicare su una flotta, crea la playlist una volta con playlist create, poi esegui screen assign --tag TAG --playlist-id ID. screen publish punta a uno schermo.

Imposta il fuso orario civile in cui viene letta una playlist programmata.

screen set-timezone <id> --timezone ZONE [--expect-rev REVISION]

screenrig screen set-timezone scr_01EXAMPLESCREEN00000000 --timezone America/Los_Angeles

Gli orari pagina sono orari civili, quindi privi di significato senza una zona. Cambiare la zona rinnova la revisione del manifesto.

Nascondi uno schermo e scurisci il vetro.

screen archive <id> [--expect-rev REVISION]

screenrig screen archive scr_01EXAMPLESCREEN00000000

L’archiviazione nasconde lo schermo dall’elenco predefinito e scurisce il vetro. Non dissocia il lettore.

Ripristina uno schermo archiviato nella lista predefinita.

screen unarchive <id> [--expect-rev REVISION]

screenrig screen unarchive scr_01EXAMPLESCREEN00000000

Un Player può anche archiviare il proprio schermo: un reset confermato su un Player che detiene una chiave, o la dissociazione di un Player browser associato tramite cookie. screen show quindi segnala archive_reason come device_reset o device_unpair (project per un archivio richiesto), con archived_at. Lo schermo mantiene il suo vincolo dispositivo per ogni motivo, quindi un Player che ancora detiene quella chiave o cookie dispositivo resta spento e riprende su ripristino senza nuova associazione. Il Player che è stato resettato o dissociato perde la sua chiave o cookie e si associa di nuovo come nuovo schermo. Una chiave sostituita da un recupero schermo confermato resta ritirata.

Uno schermo archiviato come replaced da screen replace non mantiene alcun vincolo dispositivo, quindi il ripristino dall’archivio lo rifiuta e screen delete lo rimuove.

Mostra un avviso su uno schermo al posto dei suoi contenuti, finché non viene ripreso.

screen suspend <id> --message TEXT [--expect-rev REVISION]

screenrig screen suspend scr_01EXAMPLESCREEN00000000 --message "Closed for stocktake. Back at 9am."

Uno schermo sospeso mostra il messaggio al posto dei suoi contenuti. Non cambia nient’altro: la sua playlist, la programmazione, il takeover e il controllo del display restano al loro posto e continuano a evolversi, e screen resume mostra ciò che lo schermo starebbe mostrando ora. screen show riporta suspension con message e since; sospendere uno schermo già sospeso sostituisce il messaggio e mantiene since. Sospendere aggiorna la revisione dello schermo, e il Player recupera subito i dati aggiornati. Uno schermo archiviato risponde screen_archived.

Termina la sospensione di uno schermo così che torni a mostrare i propri contenuti.

screen resume <id> [--expect-rev REVISION]

screenrig screen resume scr_01EXAMPLESCREEN00000000

Riprendere mostra di nuovo i contenuti propri dello schermo, a partire da ciò che lo schermo starebbe mostrando ora, e il Player recupera subito i dati aggiornati. Uno schermo non sospeso risponde invariato, senza cambio di revisione. Uno schermo archiviato risponde screen_archived.

Elimina uno schermo.

screen delete <id> [--expect-rev REVISION]

screenrig screen delete scr_01EXAMPLESCREEN00000000

Eliminare rimuove uno schermo solo finché nessuna chiave Player è associata ad esso, e screen show riporta deletable: true per quello schermo. Un Player che si associa tramite codice, nativo o browser, detiene una chiave, e la chiave resta associata al suo schermo: eliminare quello schermo risponde 409 screen_archive_required (codice di uscita 5); archiviarlo invece. Solo un Player browser associato tramite cookie non detiene alcuna chiave, e il suo schermo si elimina sia che sia associato sia che sia ancora in attesa.

Sposta su questo schermo il dispositivo associato come un altro schermo, mantenendo le impostazioni e la cronologia di questo schermo.

screen replace <id> --with ID [--expect-rev REVISION]

screenrig screen replace scr_01EXAMPLESCREEN00000000 --with scr_01EXAMPLENEWSCREEN000000

Associa prima il nuovo hardware come schermo a sé stante, poi sostituisci. La chiave del dispositivo, o la credenziale di un Player browser, ora apre <id>, che mantiene nome, tag, fuso orario, playlist, programmazioni, takeover, programmazione display e override, video wall, commenti, campi, posizione e cronologia, e prende l’host e il Player dello schermo sostitutivo. Salute, stato, spazio di archiviazione e comandi in coda ricominciano da zero. Lo schermo indicato da --with viene archiviato con archive_reason replaced e replaced_by che indica <id>. Non mantiene alcun vincolo dispositivo, quindi screen unarchive non può ripristinarlo e screen delete lo rimuove. La chiave che <id> deteneva viene ritirata dopo una finestra di grazia di quindici minuti, poi il suo vecchio dispositivo viene rifiutato. Entrambi gli schermi devono essere attivi con un Player associato: uno schermo ancora in attesa di associazione risponde resource_conflict, uno archiviato risponde screen_archived, e un video wall richiede un Player sostitutivo che dichiara display.wall (wall_unsupported). La richiesta porta sempre una chiave di idempotenza, e un retry esatto restituisce la risposta originale.

Emettere un nuovo ID pubblico per uno schermo.

screen rotate-public-id <id> [--expect-rev REVISION]

screenrig screen rotate-public-id scr_01EXAMPLESCREEN00000000

Crea il link di uno schermo, o sostituiscilo, e stampa il suo URL Player.

screen link create <id> [--expect-rev REVISION]

screenrig screen link create scr_01EXAMPLESCREEN00000000

Stampa data.url, l’URL Player (https://play.screenrig.ai/player/#screen=…) da incollare come URL di una sorgente browser in vMix o OBS, che non conserva dati e altrimenti perderebbe l’associazione a ogni caricamento. Il Player funziona dall’URL a ogni caricamento: l’URL è l’intera associazione. Creare di nuovo il link lo sostituisce (data.replaced è true): il vecchio URL smette subito di funzionare e il Player aperto da esso mostra un avviso senza contenuto. L’URL è una credenziale che apre lo schermo: viene stampato sotto un’etichetta sensibile, tenuto fuori dal log delle operazioni e mostrato di nuovo da screen link show. Aprilo in un solo posto. Uno schermo non ancora associato risponde resource_conflict (exit code 5), e uno schermo archiviato risponde screen_archived. Dopo una richiesta interrotta, riesegui lo stesso comando: riutilizza la chiave di idempotenza salvata e restituisce lo stesso link.

Stampa il link di uno schermo e il suo URL Player.

screen link show <id>

screenrig screen link show scr_01EXAMPLESCREEN00000000

Stampa data.url sotto un’etichetta sensibile con data.hint (gli ultimi quattro caratteri del segreto), data.created_at e data.last_used_at una volta che un Player ha aperto il link. Una credenziale di sola lettura riceve url vuoto con url_redacted true, e l’output umano dice che l’URL è trattenuto; un accesso Manage lo riceve. Uno schermo senza link risponde screen_link_not_found (exit code 4) e indica il comando che ne crea uno. screen show stampa Screen link: on (…HINT) per uno schermo che ne ha uno, e mai il suo URL.

Disattiva il link di uno schermo.

screen link delete <id> [--expect-rev REVISION]

screenrig screen link delete scr_01EXAMPLESCREEN00000000

L’URL smette subito di funzionare e ogni sessione che ha aperto termina: una sorgente browser che lo mostra ancora visualizza un avviso e nessun contenuto finché non riceve un nuovo URL. Lo schermo, la sua associazione e i suoi contenuti restano intatti. Riesce, senza cambiare nulla, quando lo schermo non ha un link.

Chiedi al lettore di uno schermo, o a tutti i lettori di una flotta, di ricaricare una volta.

screen reload (<id>... | --tag TAG) [--expires-in DURATION] [--expect-rev REVISION]

screenrig screen reload scr_01EXAMPLESCREEN00000000
screenrig screen reload scr_01EXAMPLESCREEN00000000 --expires-in 2h
screenrig screen reload --tag Lobby

La risposta include un reload_id, un state e un expires_at. Uno schermo online riceve subito la ricarica (state sent); uno schermo offline la mantiene in stato queued e la riceve quando torna online prima di expires_at, 24 ore dopo la richiesta salvo diversa indicazione in --expires-in. Una ricarica più recente sostituisce quella ancora in coda, screen show elenca i commands dello schermo e screen command cancel annulla una ricarica ancora in coda. In una flotta, il reload di ogni risultato contiene lo stesso state. Un Player web si ricarica al prossimo cambio pagina; un Player nativo si ricollega, recupera il manifesto e verifica aggiornamenti. Un Player ignora una ricarica entro dieci minuti dall’ultima eseguita. La ricarica funziona su schermi attivi e archiviati e non cambia la revisione dello schermo.

Invia un messaggio transitorio come stage chrome su uno schermo live o una flotta.

screen toast (<id>... | --tag TAG) --text TEXT [--level info] [--duration-ms MS]

screenrig screen toast scr_01EXAMPLESCREEN00000000 --text "Lobby closed"
screenrig screen toast --tag Lobby --text "Closing in ten minutes"

Un toast non è un primitivo: non occupa slot canvas, non ha layer e non partecipa a readiness o crossfade. Vince l’ultimo, non c’è coda né annulla, e l’involucro accettato è solo { expires_at }. Non mettere mai credenziali o altri materiali segreti nel testo.

Mostra il nome di uno schermo sopra i suoi contenuti per un po’, così da trovarlo in loco.

screen identify <id> [--duration DURATION]

screenrig screen identify scr_01EXAMPLESCREEN00000000
screenrig screen identify scr_01EXAMPLESCREEN00000000 --duration 2m

Il Player disegna una sovrapposizione a schermo intero sopra i propri contenuti, con il nome dello schermo molto grande e il suo ID in piccolo sotto. La riproduzione continua al di sotto, e un’identificazione più recente sostituisce la sovrapposizione. La busta accettata contiene identify_id, duration_ms e un expires_at 60 secondi dopo la richiesta, così uno schermo offline non la mostra mai in seguito. Solo un Player che dichiara la capacità identify mostra la sovrapposizione: qualsiasi altro schermo risponde 409 identify_unsupported (codice di uscita 5) e non viene inviato nulla, quindi aggiorna il Player o mostra il nome con screen toast. Uno schermo archiviato risponde screen_archived e uno schermo ancora in attesa di associazione risponde resource_conflict. Identificare non cambia la revisione dello schermo.

Cattura un fermo immagine di uno schermo attivo, o di ogni schermo in una flotta, e scrivilo su disco.

screen screenshot <id> [--output FILE] [--timeout MS] [--poll-ms MS]
screen screenshot (<id> <id>... | --tag TAG) [--output DIRECTORY] [--concurrency N] [--timeout MS] [--poll-ms MS]

screenrig screen screenshot scr_01EXAMPLESCREEN00000000 --output ./lobby.webp

screenrig screen screenshot --tag Lobby --output ./lobby-shots

Il comando blocca finché il WebP non è su disco; non esiste --no-wait. La busta riporta screen_id, capture_id, path, bytes, sha256, width e height, e mai i byte immagine. Vince l’ultimo: una richiesta successiva sostituisce una cattura in corso. Uno screenshot del Player web disegna ogni pagina iframe come un riquadro grigio scuro con l’etichetta «Embedded web page» e ogni applicazione come si renderizza da sola; l’immagine non porta alcun segno del riquadro, quindi non prova che una pagina iframe sia stata renderizzata.

Per più ID o --tag, la risposta è un risultato flotta con action: "screenshot", il selector, e la directory output; ogni risultato ok contiene path, bytes, sha256, width e height. Con --tag, la CLI elenca prima gli schermi taggati, seguendo ogni pagina di elenco; ogni pagina è fatturata e le catture sono gratuite, e più ID non richiedono elenco. --idempotency-key è rifiutato in questa forma, perché ogni cattura usa la propria chiave. Se una cattura fallisce inaspettatamente, il risultato di quello schermo è unexpected_error, non iniziano nuove catture, gli schermi in attesa riportano not_attempted e il codice di uscita è 1.

Imposta, aggiungi, rimuovi o cancella i tag su uno schermo o una flotta.

screen tag (<id>... | --tag TAG) (--set TAGS | --add TAGS | --remove TAGS | --clear) [--expect-rev REVISION]

screenrig screen tag scr_01EXAMPLESCREEN00000000 --set Lobby,Floor2
screenrig screen tag scr_01EXAMPLESCREEN00000000 --add Spring
screenrig screen tag --tag Lobby --add Spring

Un tag è da 1 a 32 lettere o cifre, e uno schermo porta al massimo 16 tag unici. I tag selezionano flotte; non sono mai autorizzazione e non raggiungono mai il Player. Cambiare i tag aggiorna la revisione dello schermo, non quella del manifesto. Per uno schermo l’involucro è lo schermo aggiornato. --add e --remove leggono prima lo schermo e scrivono il nuovo set protetto da --expect-rev o dalla revisione appena letta, così un cambiamento concorrente restituisce revision_conflict (exit 6) invece di essere sovrascritto; rilancia il comando. In una flotta, --add e --remove si applicano atomicamente contro il set memorizzato di ogni schermo, e uno schermo che supererebbe 16 tag fallisce nel proprio risultato con invalid_request.

Ovunque i tag cambino (screen tag, un aggiornamento dello schermo tramite l'API, l'editor di tag della dashboard), il levels della risposta elenca, sotto gained e lost, le campagne il cui pubblico di tag lo schermo ha raggiunto o lasciato, ciascuna con il suo source (campaign), il suo id, il conteggio di screens e, quando la campagna ha una copertura, reach_before e reach_after. Un screen tag di flotta li somma sulla flotta. Leggi levels.lost prima di considerare innocua una modifica di tag: rimuovere l'ultimo tag corrispondente dagli schermi di una campagna svuota quel gruppo e fa scattare le notifiche reach_dropped e group_empty.

Mostra la programmazione della playlist di uno schermo e la playlist attualmente selezionata.

screen schedule show <id>

screenrig screen schedule show scr_CAFE

L’output JSON può tornare direttamente a screen schedule set --file.

Sostituisci la programmazione playlist su uno schermo o una fleet.

screen schedule set (<id>... | --tag TAG) --file FILE [--expect-rev REVISION] [--note TEXT]

screenrig screen schedule set scr_CAFE --file dayparts.json
screenrig screen schedule set --tag Cafe --file dayparts.json

Ogni playlist nominata da una programmazione è validata come assegnazione, e lo schermo necessita di un fuso orario e una playlist predefinita assegnata. Quando nessuna voce è in vigore, si riproduce la playlist assegnata. Se una playlist programmata non può più essere mostrata, le sue voci sono saltate e screen.playlist_unavailable è registrato.

Rimuovi la programmazione playlist da uno schermo o una flotta.

screen schedule clear (<id>... | --tag TAG) [--expect-rev REVISION] [--note TEXT]

screenrig screen schedule clear --tag Cafe

Mostrare cosa cambierebbe sostituire il programma di playlist di uno schermo, senza farlo.

screen schedule preview <id> --file FILE [--calendar-from INSTANT] [--calendar-to INSTANT]

screenrig screen schedule preview scr_LOBBY --file dayparts.json
screenrig screen schedule preview scr_LOBBY --file dayparts.json --calendar-from 2026-12-01T00:00:00Z --calendar-to 2027-01-01T00:00:00Z

Non viene scritto nulla. Le voci sono controllate come le controlla screen schedule set, perciò un’anteprima rifiuta ciò che rifiuta il set. data.gained e data.lost dicono se lo schermo guadagnerebbe o perderebbe livelli del suo programma; una voce con "paused": true non è su alcuno schermo, quindi pubblicarla la guadagna. data.calendar.before e data.calendar.after sono il calendario dello schermo com’è e come sarebbe da --calendar-from a --calendar-to.

Elenca le revisioni del programma di playlist di uno schermo, la più recente per prima.

screen schedule revisions <id> [--after CURSOR]

screenrig screen schedule revisions scr_LOBBY
screenrig screen schedule revisions scr_LOBBY --after CURSOR

data.items contiene al massimo 50 revisioni, ciascuna con revision (la revisione dello schermo alla scrittura, perciò i numeri hanno lacune dove lo schermo è cambiato in altro modo), created_at, change, current, author quando noto e entries, l’intero programma dopo quella scrittura (none significa che lo schermo non aveva un programma). change è edited (un set, un clear o un’importazione di programmi), restored (una copia della revisione precedente indicata da restored_from) oppure baseline. Finché data.next_cursor è una stringa, restano revisioni più vecchie: esegui di nuovo il comando con --after impostato su quel valore. Le revisioni vanno via con l’eliminazione definitiva dello schermo. Basta l’accesso in sola lettura.

Rimettere su uno schermo il programma di una revisione precedente copiandolo in avanti.

screen schedule restore <id> --revision N [--expect-rev REVISION] [--note TEXT]

screenrig screen schedule restore scr_LOBBY --revision 4
screenrig screen schedule restore scr_LOBBY --revision 4 --expect-rev 9

Le voci della revisione N diventano il programma dello schermo, la stessa scrittura di screen schedule set con quelle voci (o screen schedule clear se quella revisione non ne aveva), controllate come lo sono ora: una playlist eliminata nel frattempo la rifiuta. Con accesso Propose, o in un progetto che richiede revisione per le modifiche degli agenti, il ripristino attende una persona come il set, e sullo schermo non cambia nulla finché non lo approva. Le revisioni precedenti restano com’erano.

Mostra una playlist su uno schermo o una flotta prima delle campagne, della programmazione e dell’assegnazione.

screen takeover [set] (<id>... | --tag TAG) --playlist-id ID [--until TIME | --for DURATION] [--reason TEXT] [--expect-rev REVISION] [--note TEXT]

screenrig screen takeover scr_LOBBY --playlist-id pl_DRILL --for 30m --reason "Fire drill"
screenrig screen takeover --tag Lobby --playlist-id pl_LAUNCH --for 2h
screenrig screen takeover scr_A scr_B --playlist-id pl_NOTICE --until none

screen takeover ID è l’abbreviazione di screen takeover set ID. Un nuovo takeover sostituisce quello precedente. Quando termina, lo schermo torna automaticamente a una campagna in vigore, al suo programma o alla playlist assegnata. Un takeover la cui playlist non può essere mostrata termina. Una riesecuzione --for dopo un errore ambiguo calcola una nuova fine ed è inviata come nuova richiesta.

Termina il takeover su uno schermo o una flotta.

screen takeover clear (<id>... | --tag TAG) [--expect-rev REVISION] [--note TEXT]

screenrig screen takeover clear --tag Lobby

Elenca le campagne del progetto nell’ordine in cui gli schermi le leggono.

campaign list

Nessun parametro.

screenrig campaign list

data.items contiene al massimo 100 campagne, prima quelle con la priorità più alta e, a parità di priorità, le più recenti per prime. Una campagna in pausa è elencata e non si applica da nessuna parte.

Leggi una campagna.

campaign show <id>

screenrig campaign show cmp_LUNCH

Restituisce name, playlist_id, audience (la regola esatta), priority, paused, i from, until, windows, monthly, dates, except, interaction, displays e start impostati, e revision, il valore per --expect-rev in una scrittura successiva. reach riporta quanti schermi il pubblico comprende: published quando la campagna è stata pubblicata l'ultima volta (creata, o aggiornata con un nuovo pubblico, una nuova playlist o uno stato di pausa), current e at per il conteggio più recente, e empty_groups, le foglie tag:NAME e folder:ID del pubblico che non corrispondono ad alcuno schermo. Un tag, una cartella, un'archiviazione o un'eliminazione che cambia il conteggio viene ricalcolato entro circa 15 secondi; campaign list riporta anche reach, e le notifiche reach_dropped e group_empty lo controllano. Un id da ads campaigns list risponde qui con not_found (exit 4).

Commuta gli schermi di un pubblico su una playlist, sempre o finché sono in vigore le sue regole.

campaign create --name NAME --playlist-id ID (--tag TAG | --any-tag TAG | --screen-id ID | --folder ID | --all-screens | --audience RULE) [--from TIME] [--until TIME] [--window SPEC] [--monthly SPEC] [--date SPEC] [--except DATES] [--on-touch [IDLE_S]] [--displays N[,N]] [--start on-time|next-item] [--covers WHERE] [--priority N] [--paused]

screenrig campaign create --name "Lunch menu" --playlist-id pl_LUNCH --tag north --window mon-fri@11:00-14:00
screenrig campaign create --name "North Tower welcome" --playlist-id pl_WELCOME --folder sfd_01EXAMPLEFOLDER000000000
screenrig campaign create --name "Holiday hours" --playlist-id pl_HOLIDAY --tag Lobby --from 2026-12-20T00:00 --until 2027-01-02T00:00 --priority 10
screenrig campaign create --name "North cafes" --playlist-id pl_CAFE --audience '{"all":[{"tag":"North"},{"any":[{"tag":"Cafe"},{"tag":"Patio"}]}]}' --paused
screenrig campaign create --name "Brunch" --playlist-id pl_BRUNCH --tag Cafe --monthly 1st-sun@10:00-14:00 --except 2026-12-06
screenrig campaign create --name "Touch to browse" --playlist-id pl_MENU --screen-id scr_KIOSK --on-touch 90
screenrig campaign create --name "Holiday opening" --playlist-id pl_HOLIDAY --tag Lobby --date 2026-12-24@18:00-22:00 --start on-time
screenrig campaign create --name "Wall outputs 1 and 2" --playlist-id pl_WALL --screen-id scr_WALL --displays 1,2

I tag sono da 1 a 32 lettere o cifre. DAYS è daily, un giorno (mon), un intervallo (mon-fri; fri-mon supera la fine della settimana) o un elenco separato da virgole (sat,sun). Senza un orario la finestra è l’intera giornata, e una fine uguale o precedente all’inizio attraversa la mezzanotte e appartiene al giorno di inizio. In una regola --audience ogni membro ha esattamente uno tra all, any, tag, screen_id o folder, i gruppi si annidano al massimo a 3 livelli, un pubblico ha al massimo 500 regole e {"all":[]} è ogni schermo.

Dopo una creazione interrotta o ambigua, riesegui lo stesso comando entro 24 ore: riutilizza la chiave di idempotenza salvata e il server restituisce la stessa campagna invece di crearne un’altra.

Modifica una campagna; gli schermi del suo vecchio e del suo nuovo pubblico vengono rivalutati entro un minuto.

campaign update <id> [--name NAME] [--playlist-id ID] [audience option] [--from TIME | --clear-from] [--until TIME | --clear-until] [--window SPEC | --clear-windows] [--monthly SPEC | --clear-monthly] [--date SPEC | --clear-dates] [--except DATES | --clear-except] [--on-touch [IDLE_S] | --clear-on-touch] [--displays N[,N] | --clear-displays] [--start WHEN] [--covers WHERE] [--priority N] [--expect-rev REVISION]

screenrig campaign update cmp_LUNCH --playlist-id pl_LUNCH2 --expect-rev 2
screenrig campaign update cmp_LUNCH --tag Lobby --window sat,sun --priority 20
screenrig campaign update cmp_LUNCH --clear-until --clear-windows
screenrig campaign update cmp_BRUNCH --monthly 2nd-sun@10:00-14:00 --except 2026-12-13,2027-01-10
screenrig campaign update cmp_BROWSE --clear-on-touch --clear-displays

Passa almeno una modifica; cambiano solo i campi passati. Un nuovo --playlist-id è verificato come in creazione. Dopo una richiesta interrotta o ambigua, riesegui lo stesso comando: riutilizza la chiave di idempotenza salvata e il server restituisce l’aggiornamento già avvenuto invece di applicarlo di nuovo.

Ferma una campagna su ogni schermo senza eliminarla.

campaign pause <id> [--expect-rev REVISION]

screenrig campaign pause cmp_LUNCH

Gli schermi che la mostravano tornano a ciò che mostrerebbero senza di essa entro un minuto. campaign resume l’avvia di nuovo.

Avvia di nuovo una campagna in pausa.

campaign resume <id> [--expect-rev REVISION]

screenrig campaign resume cmp_LUNCH

Ogni schermo del pubblico a cui la campagna può applicarsi passa alla sua playlist entro un minuto finché la campagna è in vigore.

Elimina una campagna.

campaign delete <id> [--expect-rev REVISION]

screenrig campaign delete cmp_LUNCH

La campagna non ritorna. Ogni schermo che la mostra torna a ciò che mostrerebbe senza di essa entro un minuto; playlist, schermi e tag restano. campaign pause ferma una campagna e la conserva.

Mostra gli schermi raggiunti da una campagna e lo stato di ciascuno.

campaign screens <id> [--limit N] [--cursor CURSOR]