Introduzione

JuliuS espone un server HTTP locale basato su Indy TIdHTTPServer che consente il controllo remoto del motore di scripting e del browser embedded (Chromium CEF). Tutti gli endpoint usano una singola rotta con parametri in query string.

Gli endpoint sono divisi in tre macro-aree: Browser CEF (operazioni dentro il browser embedded), Ispezione pagina / DevTools (lettura del DOM, frame, network), OS (mouse e tastiera a livello sistema operativo, per finestre native fuori dal browser).

Base URL & Autenticazione

http://<host>:<port>/
⚠ Attenzione: Al momento JuliuS non prevede autenticazione. Esporre il server solo su localhost o reti fidate.

Carica script da file

GET/?loadscript={filename}Carica uno script dal disco
Carica un file di script dalla cartella configurata in Settings.Data.scriptPath e lo apre nell'editor grafico di JuliuS. Usare questo endpoint quando lo script da eseguire risiede già sul disco della macchina che ospita JuliuS. L'estensione .js viene aggiunta automaticamente se il file non viene trovato senza di essa, rendendo opzionale specificarla nella chiamata. Il caricamento è asincrono: la risposta arriva immediatamente, ma l'apertura dell'editor avviene nel thread principale poco dopo.
async
200OK
200*Errore, file non trovato [...]
GET /?loadscript=login_flow HTTP/1.1

Carica script da stream

POST/?operation=readscritpfromstreamInvia uno script via body
Invia il sorgente dello script direttamente nel body della richiesta POST, senza necessità di un file su disco. È la modalità ideale per sistemi di orchestrazione esterni (es. ScrapManager) che generano o modificano gli script a runtime prima di inviarli a JuliuS. Lo script viene aperto nell'editor con il titolo "Script from remote". Se il body è assente o la lettura fallisce, viene restituito un messaggio di errore ma il server non va in eccezione.
async
200OK
200*Errore nello scritp — body assente o errore lettura
POST /?operation=readscritpfromstream HTTP/1.1 Content-Type: text/plain // script remoto var x = doSomething();

Avvia esecuzione

GET/?operation=start[&params...]Avvia lo script corrente
Avvia l'esecuzione dello script attualmente caricato nell'editor di JuliuS, a partire dalla riga indicata da currentLine. Prima di chiamare questo endpoint è buona pratica verificare lo stato con ?operation=status: se un processo è già in esecuzione la chiamata viene rifiutata con un messaggio esplicito, evitando esecuzioni concorrenti. I parametri excelLine e remoteVirtualPath impostano il contesto di logging e upload degli screenshot, usati dallo script durante l'esecuzione.
async
ParametroObbligatorioDescrizione
operation✓Deve essere start
currentLineRiga di partenza dell'esecuzione
excelLineNome base della riga nel log Excel, usato per nominare i file di screenshot
remoteVirtualPathPath virtuale remoto per l'upload degli screenshot (_ viene sostituito con /). Il trailing / viene aggiunto automaticamente.
200started
200*Already Running, check status before try to start another process
200*Script is not already initiated — nessun form di script aperto

Ferma esecuzione

GET/?operation=stopInterrompe lo script in esecuzione
Interrompe lo script in esecuzione richiamando frmScript.stopExecution nel thread principale. L'operazione gestisce correttamente sia lo stato running che lo stato paused, rimuovendo entrambi i flag di stato. Viene inoltre chiusa ogni finestra popup figlia aperta durante l'esecuzione. Se non è in corso alcuna esecuzione la chiamata è un no-op silenzioso.
async
GET /?operation=stop HTTP/1.1

Reset cursore

GET/?operation=resetRiporta il cursore dell'editor a riga 1
Sposta il cursore dell'editor SynEdit alla prima riga dello script, preparando una nuova esecuzione dall'inizio. Utile nei flussi automatizzati per garantire che lo script riparta sempre dall'inizio dopo un ciclo completato. L'operazione è protetta: se uno script è attualmente in esecuzione (IsRunning = true) la chiamata viene ignorata silenziosamente senza restituire errori, evitando interferenze con il processo in corso.
async
Nota: Ignorato silenziosamente se uno script è in esecuzione (IsRunning = true).

Status

GET/?operation=statusVerifica lo stato del motore di scripting
Restituisce lo stato corrente del motore di scripting di JuliuS. È l'endpoint di polling fondamentale da chiamare prima di ogni start per evitare avvii multipli, e durante l'esecuzione per rilevare quando uno script è terminato. Lo stato tiene conto sia dell'esecuzione attiva dello script che del caricamento della pagina nel browser (MainBrowserFrm.FPageLoading): se la pagina è ancora in caricamento il sistema risulta occupato anche se lo script è tecnicamente in pausa.
sync
200on working — script in esecuzione o pagina in caricamento
200no operation progress — sistema idle, pronto per un nuovo start

Get Result (funzione fissa)

GET/?operation=getresultEsegue preventivo() e ritorna il risultato
Chiama nel browser la funzione JavaScript preventivo() — la funzione di estrazione del risultato per convenzione negli script JuliuS — e restituisce il suo valore serializzato come JSON di TOperationResult. Il JSON include il risultato grezzo, l'ID operazione, la data di avvio e la lista degli screenshot catturati. Da usare al termine di uno script di preventivazione per recuperare il valore calcolato. Per funzioni con nome diverso usare l'endpoint Get Result variabile.
sync

Get Result (funzione variabile)

GET/?getresult={functionName}Esegue una funzione JS arbitraria e ritorna il risultato
Versione generalizzata di getresult: esegue nel browser la funzione JavaScript il cui nome viene passato come parametro, aggiungendo automaticamente le parentesi (). Restituisce il valore in formato JSON TOperationResult, esattamente come l'endpoint fisso. Usare questo endpoint quando lo script espone funzioni di estrazione con nomi personalizzati (es. getOrderTotal, calcolaPremio) invece della funzione standard preventivo(). La funzione deve essere già definita nel contesto JS del browser al momento della chiamata.
sync
ParametroDescrizione
getresultNome della funzione JS da eseguire, senza parentesi. Le () vengono aggiunte automaticamente.
GET /?getresult=getOrderTotal HTTP/1.1

Click (CEF)

GET/?operation=click&X={x}&Y={y}Simula un click nel browser CEF
Invia un click sintetico al browser Chromium embedded nelle coordinate pixel specificate, relative al pannello CEF. È utile per interagire con elementi non facilmente raggiungibili via JavaScript (canvas, WebGL, elementi con gestori di eventi custom). Le coordinate devono essere calibrate rispetto alla risoluzione impostata con SCREEN_SIZE. Per click su finestre native Windows o dialog di sistema usare invece gli endpoint OS Mouse, che agiscono a livello sistema operativo.
sync
ParametroDescrizione
XCoordinata X in pixel relativa al pannello CEF
YCoordinata Y in pixel relativa al pannello CEF
GET /?operation=click&X=320&Y=240 HTTP/1.1

Snapshot (CEF)

GET/?operation=snapshotScreenshot del browser CEF come stream JPG
Cattura lo stato visuale corrente del browser CEF embedded e lo restituisce come stream binario JPG. L'header custom scalefactor indica il fattore di scala DPI del monitor e va usato dal client per interpretare correttamente le dimensioni dell'immagine in ambienti con display ad alta densità (HiDPI). Questo endpoint cattura solo il pannello del browser, non l'intera finestra di JuliuS né il desktop. Per screenshot dell'intero desktop usare osscreenshotjpg.
syncbinary stream
Header rispostaValore
Content-Typeimage/jpg
scalefactorFattore DPI del monitor (es. 1.25 per display 125%)
curl "http://127.0.0.1:8080/?operation=snapshot" --output screenshot.jpg

Restart Chromium

GET /?operation=restartchromium Reset sessione Chromium in memoria

Azzera la sessione Chromium embedded senza riavviare l'applicazione. Tramite DevTools Protocol cancella cache HTTP, cookie, localStorage, sessionStorage e IndexedDB, poi naviga su about:blank. Risponde solo quando il reset è completato.

sync

Risposta

200 chromium_restarted — reset completato
200* ERROR: ... — messaggio di errore

Esempio

GET /?operation=restartchromium HTTP/1.1 Host: 127.0.0.1:8080 → chromium_restarted

Delete Chromium Cache

GET /?operation=deletechromiumcache Pulizia profonda: memoria + file su disco

Esegue un reset completo della cache Chromium: svuota cache HTTP, cookie e storage tramite DevTools Protocol, poi cancella fisicamente la directory GlobalCEFApp.RootCache su disco. Più lenta di restartchromium — usare per cache corrotta o per garantire una sessione indistinguibile da un avvio a freddo.

sync

Confronto con restartchromium

Azionerestartchromiumdeletechromiumcache
Cache HTTP in memoria✅✅
Cookie in memoria✅✅
LocalStorage / IndexedDB✅✅
File cache su disco❌✅
Tempo medio~3 s~5 s

Risposta

200 chromium_cache_deleted — pulizia completata
200* ERROR: ... — messaggio di errore

Esempio

GET /?operation=deletechromiumcache HTTP/1.1 Host: 127.0.0.1:8080 → chromium_cache_deleted

Get DOM

GET/?operation=getdomRestituisce l'outerHTML completo della pagina
Ritorna il sorgente HTML completo della pagina attualmente caricata nel browser, ottenuto tramite document.documentElement.outerHTML. È utile per analisi offline del DOM, debug di pagine con rendering dinamico o per verificare lo stato attuale della pagina prima di eseguire interazioni. Poiché restituisce il DOM live (post JavaScript, non il sorgente originale del server), riflette lo stato effettivo della pagina incluse le modifiche apportate dagli script già eseguiti.
sync
200HTML completo della pagina — text/html; charset=utf-8
200*ERROR: ... — eccezione interna

Get Form Fields

GET/?operation=getformfieldsElenca tutti i campi form della pagina in JSON
Analizza il DOM della pagina corrente e restituisce un array JSON con tutti gli elementi interattivi dei form: input, select, textarea e button. Per ogni elemento vengono incluse proprietà come id, name, type, value e visible. Particolarmente utile in fase di sviluppo di uno script, per identificare gli ID degli elementi da usare nei comandi WRITETO senza dover ispezionare manualmente il sorgente della pagina.
sync
200JSON array dei campi form — application/json; charset=utf-8
200*ERROR: ... — eccezione interna

Get Page Info

GET/?operation=getpageinfoMetadati sulla pagina corrente
Restituisce un oggetto JSON con le informazioni essenziali sulla pagina attualmente caricata: URL corrente, titolo del documento, readyState e lista degli iframe presenti con i relativi URL. È l'endpoint ideale per verificare rapidamente su quale pagina si trova il browser, controllare che il caricamento sia completo (readyState === "complete") e identificare la struttura dei frame prima di usare TARGET_FRAME negli script.
sync
200JSON con url, title, readyState, lista iframes — application/json; charset=utf-8
200*ERROR: ... — eccezione interna

Get Console Log

GET/?operation=getconsolelogRecupera i messaggi della console JavaScript
Installa automaticamente un listener sulla console JavaScript del browser (se non già attivo) e restituisce tutti i messaggi console.log, console.warn ed console.error accumulati fino a quel momento. Indispensabile per il debug dei blocchi SNIPPET negli script, che tipicamente usano console.log() per tracciare l'esecuzione. I messaggi vengono accumulati in memoria e restituiti ad ogni chiamata senza essere svuotati, salvo reset esplicito.
sync
200JSON array dei messaggi console — application/json; charset=utf-8
200*ERROR: ... — eccezione interna

EvalJS (via API)

GET/?evaljs={expression}Valuta un'espressione JavaScript arbitraria nel browser
Esegue una singola espressione JavaScript nel contesto del browser CEF e ne restituisce il valore come testo semplice. A differenza di ?operation=getresult, il risultato non viene registrato nel TOperationResult corrente ma restituito direttamente nella risposta HTTP. L'espressione deve essere URL-encoded. Utile per interrogazioni rapide del DOM o per verificare lo stato di variabili JS senza dover definire una funzione dedicata nello script.
sync
200Risultato dell'espressione come stringa — text/plain; charset=utf-8
200*ERROR: ... — eccezione interna o errore JS
# Legge il titolo della pagina GET /?evaljs=document.title # Verifica la visibilità di un elemento (selettore URL-encoded) GET /?evaljs=%24('%23btnAvanti').is('%3Avisible')

Find Element

GET/?findelement={css_selector}Verifica l'esistenza di un elemento CSS nel DOM
Verifica se un selettore CSS è presente nel DOM della pagina corrente e restituisce un oggetto JSON con le proprietà dell'elemento trovato, tra cui id, tagName, value, visible e boundingRect. Utile per implementare logica condizionale nei flussi di automazione: verificare che un pulsante sia presente prima di cliccare, attendere la comparsa di un elemento di risultato o rilevare messaggi di errore nella pagina. Il selettore deve essere URL-encoded.
sync
200JSON con le proprietà dell'elemento trovato — application/json; charset=utf-8
200*ERROR: ... — eccezione interna
# Cerca per ID (# URL-encoded = %23) GET /?findelement=%23btnAvanti # Cerca per classe GET /?findelement=.risultato-finale

Get Frame List

GET/?operation=getframelistLista di tutti i frame aperti nel browser
Restituisce un array JSON con tutti i frame attualmente aperti nel browser CEF: frame principale, iframe e frame figlio. Per ogni frame vengono forniti name, id, url, il flag isMain e il flag isFocused. È l'endpoint di riferimento da consultare prima di usare la direttiva TARGET_FRAME=POPUP negli script, per identificare esattamente il nome o l'URL del frame target. Particolarmente utile con pagine che aprono popup o usano frame annidati.
sync
200JSON array con name, id, url, isMain, isFocused
200*{"error":"..."}

Get Frame Source

GET/?operation=getframesource[&frame={name}]HTML sorgente di un frame specifico
Legge e restituisce l'HTML sorgente di un frame specifico identificato per nome, includendo il supporto per frame cross-origin che normalmente non sarebbero accessibili via JavaScript standard per policy di sicurezza. Se il parametro frame viene omesso, viene restituito il sorgente del frame principale. Utile per ispezionare il contenuto di iframe di terze parti, form caricati in frame separati o popup figlio aperti durante la navigazione.
sync
ParametroObbligatorioDescrizione
frameNome del frame target. Se omesso → frame principale.
200HTML del frame — text/html; charset=utf-8
200*ERROR: ... — frame non trovato o errore interno
GET /?operation=getframesource&frame=contentFrame HTTP/1.1

Wait Page Load

GET/?operation=waitpageload[&timeout={ms}]Attende il completamento del caricamento della pagina
Blocca la risposta HTTP finché la pagina nel browser non ha terminato il caricamento (o finché non scade il timeout). A differenza dei WAIT fissi negli script, questo endpoint si adatta ai tempi reali del server: restituisce la risposta non appena la pagina è pronta, riducendo i tempi di attesa inutili. La richiesta gira nel thread HTTP senza bloccare il main thread dell'applicazione. Il timeout predefinito è 15 secondi e può essere aumentato per pagine particolarmente lente.
sync (bloccante)
ParametroDefaultDescrizione
timeout15000Timeout massimo di attesa in millisecondi
200loaded — pagina caricata correttamente entro il timeout
200*timeout — il timeout è scaduto prima del completamento del caricamento
GET /?operation=waitpageload&timeout=20000 HTTP/1.1

DevTools Protocol

GET/?devtools={method}[&params={json}]Esegue un comando Chrome DevTools Protocol
Permette di eseguire qualsiasi comando del Chrome DevTools Protocol (CDP) direttamente sul browser CEF, aprendo l'accesso a funzionalità avanzate non esposte dalle API standard: emulazione di dispositivi, intercettazione di richieste di rete, profiling, accesso al DOM a basso livello e molto altro. Il parametro params accetta un oggetto JSON URL-encoded con i parametri specifici del comando CDP. Consultare la documentazione CDP ufficiale per la lista completa dei metodi disponibili.
sync
ParametroObbligatorioDescrizione
devtools✓Metodo CDP da eseguire (es. Network.enable, DOM.getDocument)
paramsParametri del comando come JSON URL-encoded
200JSON con la risposta del comando CDP
200*{"error":"..."} — metodo non valido o errore CDP
# Abilita il tracking delle richieste di rete GET /?devtools=Network.enable # Valuta un'espressione tramite Runtime CDP GET /?devtools=Runtime.evaluate¶ms=%7B%22expression%22%3A%22document.title%22%7D

Start Network Log

GET/?operation=startnetworklogAvvia il logging delle chiamate di rete
Svuota il buffer del log di rete precedente e abilita Network.enable tramite il Chrome DevTools Protocol per intercettare tutte le richieste HTTP/HTTPS effettuate dal browser: XHR, fetch, caricamento di risorse. Va chiamato prima di navigare verso la pagina da monitorare, in modo da non perdere le prime richieste. I dati raccolti sono poi recuperabili con ?operation=getnetworklog. Utile per analizzare le API chiamate da una pagina web o per identificare endpoint da replicare.
sync
200network log started
200*ERROR: ... — eccezione interna

Get Network Log

GET/?operation=getnetworklogRecupera il log delle richieste di rete intercettate
Restituisce il log accumulato delle richieste di rete intercettate dopo una chiamata a startnetworklog. Il log è un array JSON in cui ogni entry contiene il metodo HTTP (method), l'URL completo (url) e il tipo di risorsa (type, es. XHR, Fetch, Document). Chiamare questo endpoint più volte non azzera il log: il buffer cresce fino al prossimo startnetworklog. Ideale per reverse engineering delle API di una pagina web o per verificare le chiamate effettuate durante l'esecuzione di uno script.
sync
200JSON array con method, url, type per ogni richiesta — application/json; charset=utf-8
200*{"error":"..."}

OS Mouse — Move

GET/?operation=osmousemove&x={x}&y={y}Sposta il cursore del mouse a coordinate assolute di schermo
Sposta il cursore del mouse alle coordinate assolute di schermo usando le API native del sistema operativo Windows (TCrossSO.SetMousePos). A differenza dell'endpoint click CEF che agisce dentro il browser embedded, questo endpoint controlla il cursore a livello SO ed è in grado di interagire con qualsiasi finestra visibile sul desktop: dialog nativi Windows, popup di sistema, finestre di altre applicazioni o la stessa interfaccia di JuliuS. Usare in combinazione con osmouseclick per eseguire click precisi su elementi nativi.
syncOS
200moved
200*ERROR: ...
GET /?operation=osmousemove&x=500&y=300 HTTP/1.1

OS Mouse — Click sinistro

GET/?operation=osmouseclickSimula un click sinistro nella posizione corrente del cursore
Simula la pressione e il rilascio del tasto sinistro del mouse nella posizione corrente del cursore di sistema, tramite TCrossSO.MouseLClick. Deve essere preceduto da una chiamata a osmousemove per posizionare correttamente il cursore. Agisce a livello sistema operativo, quindi funziona su qualsiasi finestra attiva sul desktop, non solo sul browser CEF. Per spostamento e click in un'unica operazione atomica usare osmousemoveclick.
syncOS
200clicked

OS Mouse — Move + Click

GET/?operation=osmousemoveclick&x={x}&y={y}Sposta il cursore e clicca in un'unica operazione
Combina spostamento del cursore e click sinistro in una singola chiamata API, con una pausa di 50ms tra le due operazioni per consentire al sistema operativo di aggiornare la posizione del cursore prima del click. È l'endpoint più efficiente per click su coordinate fisse, in quanto riduce il numero di round-trip HTTP rispetto a due chiamate separate. Ideale per automazioni veloci che devono cliccare su molti elementi in sequenza.
syncOS
200moved_and_clicked
GET /?operation=osmousemoveclick&x=640&y=480 HTTP/1.1

OS Mouse — Click destro

GET/?operation=osmouserclickSimula un click destro nella posizione corrente del cursore
Simula la pressione e il rilascio del tasto destro del mouse nella posizione corrente del cursore, tramite TCrossSO.MouseRClick. Utile per aprire menu contestuali nativi del sistema operativo o di applicazioni Windows che non espongono i propri elementi tramite interfaccia web. Come gli altri endpoint OS mouse, agisce a livello di sistema operativo e non è vincolato al browser CEF.
syncOS
200right_clicked

OS Mouse — Get posizione

GET/?operation=osmouseposRestituisce la posizione corrente del cursore di sistema
Legge e restituisce le coordinate assolute di schermo del cursore del mouse come oggetto JSON {"x": N, "y": N}. Utile durante lo sviluppo e il debug di automazioni per calibrare le coordinate da usare negli endpoint osmousemove e osmousemoveclick, o per verificare che il cursore si trovi nella posizione attesa prima di eseguire un click.
syncOS
200{"x":320,"y":240} — application/json; charset=utf-8
200*{"error":"..."}

OS Tastiera — Key Press

GET/?operation=oskeypress&key={keycode}Simula la pressione di un tasto tramite keycode numerico
Invia la pressione di un tasto alla finestra attiva del sistema operativo tramite il suo keycode Virtual Key (VK). A differenza di WRITETO che scrive nel browser CEF, questo endpoint agisce a livello SO e può controllare qualsiasi finestra attiva: dialog nativi Windows, form non web, applicazioni desktop. Per tasti comuni (ENTER, ESC, TAB) sono disponibili gli shortcut dedicati più leggibili; usare questo endpoint quando si ha bisogno di un tasto specifico non coperto dagli shortcut.
syncOS
KeycodeTastoKeycodeTasto
13ENTER27ESC
9TAB32SPAZIO
8BACKSPACE46DELETE
37← LEFT38↑ UP
39→ RIGHT40↓ DOWN
112–123F1–F1265–90A–Z
200key_pressed
GET /?operation=oskeypress&key=13 HTTP/1.1 # preme ENTER sulla finestra attiva

OS Tastiera — Shortcut tasti comuni

GET/?operation={oskeyXXX}Shortcut nominativi per i tasti più utilizzati
Alias nominativi per i tasti più frequentemente usati nelle automazioni, più leggibili rispetto ai keycode numerici di oskeypress. Ogni endpoint esegue esattamente la stessa operazione del corrispondente keycode numerico, ma rende i log e le sequenze di automazione immediatamente comprensibili. Usare questi shortcut ogni volta che è possibile; ricorrere a oskeypress con keycode numerico solo per tasti non coperti da questi alias.
syncOS
OperationTastoRisposta
oskeyenterENTER (↵)enter
oskeyescESCesc
oskeytabTAB (⇥)tab
oskeybackspaceBACKSPACE (⌫)backspace
GET /?operation=oskeyenter HTTP/1.1 GET /?operation=oskeyesc HTTP/1.1

OS Tastiera — Arrow Keys

GET/?operation=oskeyarrow&dir={up|down|left|right}Simula la pressione dei tasti freccia direzionali
Invia la pressione di uno dei quattro tasti freccia direzionali alla finestra attiva del sistema operativo. Utile per navigare in dropdown nativi, scorrere liste, muoversi tra campi di un form Windows o controllare applicazioni desktop che rispondono ai tasti freccia. Il parametro dir accetta i valori up, down, left, right in minuscolo; valori non riconosciuti vengono ignorati silenziosamente.
syncOS
dirTasto
up↑ Freccia su
down↓ Freccia giù
left← Freccia sinistra
right→ Freccia destra
200arrow_down / arrow_up / ecc.
GET /?operation=oskeyarrow&dir=down HTTP/1.1

OS Tastiera — Key Combo

GET/?operation=oskeycombо&combo={modifier+key}Combinazione di tasti SO (Ctrl/Shift/Alt + tasto)
Simula una combinazione di tasti a livello sistema operativo tramite keybd_event delle API Windows. Il parametro combo accetta la sintassi modificatore+tasto in minuscolo, URL-encoded se necessario. Il modificatore può essere ctrl, shift o alt; il tasto può essere una lettera singola (a–z) oppure un tasto speciale per nome. Disponibile solo su piattaforma Windows: su altre piattaforme l'endpoint risponde con un messaggio di errore esplicito senza generare eccezioni.
syncOS
Campo comboValori accettati
modifierctrl, shift, alt
keyLettera singola (a–z), oppure: f4–f6, f10–f12, tab, enter, esc, del, home, end, pageup, pagedown
200combo_ctrl+c — conferma della combinazione eseguita
200*ERROR: formato combo non valido, usare modifier+key
200*ERROR: tasto non riconosciuto [...]
200*ERROR: oskeycombо not implemented on this platform
# Copia (Ctrl+C) GET /?operation=oskeycombо&combo=ctrl+c # Incolla (Ctrl+V) GET /?operation=oskeycombо&combo=ctrl+v # Chiudi finestra (Alt+F4) GET /?operation=oskeycombо&combo=alt+f4 # Seleziona tutto (Ctrl+A) GET /?operation=oskeycombо&combo=ctrl+a # Tab inverso (Shift+Tab) GET /?operation=oskeycombо&combo=shift+tab

OS Screenshot (PNG)

GET/?operation=osscreenshotScreenshot dell'intero desktop Windows in formato PNG
Cattura l'intero desktop Windows — inclusi taskbar, popup nativi, dialog di sistema e qualsiasi finestra aperta — e lo restituisce come stream binario PNG. A differenza di snapshot che cattura solo il pannello del browser CEF, questo endpoint fotografa tutto ciò che è visibile sullo schermo. L'header scalefactor indica il fattore DPI del monitor. Usare la variante osscreenshotjpg quando la dimensione del file è prioritaria rispetto alla qualità.
syncOSbinary stream
Header rispostaValore
Content-Typeimage/png
scalefactorFattore DPI del monitor
200Stream PNG dell'intero desktop
200*ERROR: screenshot failed
curl "http://127.0.0.1:8080/?operation=osscreenshot" --output desktop.png

OS Screenshot (JPG)

GET/?operation=osscreenshotjpgScreenshot dell'intero desktop Windows in formato JPG
Variante JPG dell'endpoint osscreenshot: cattura l'intero desktop Windows e lo restituisce compresso in JPEG con qualità 45 (la stessa usata per lo snapshot del browser CEF). Produce file significativamente più leggeri rispetto al PNG, al costo di una lieve perdita qualitativa sulle aree di testo. È la variante consigliata per i flussi di debug e monitoraggio frequente, dove la velocità di trasferimento è più importante della fedeltà dell'immagine.
syncOSbinary stream
Header rispostaValore
Content-Typeimage/jpg
scalefactorFattore DPI del monitor
200Stream JPG dell'intero desktop
200*ERROR: screenshot failed
curl "http://127.0.0.1:8080/?operation=osscreenshotjpg" --output desktop.jpg

Get Browser Window Info

GET/?operation=getbrowserwindowinfoPosizione e dimensioni della finestra JuliuS e del pannello CEF
Restituisce un oggetto JSON con la posizione e le dimensioni sia della finestra principale di JuliuS (mainForm) che del pannello browser CEF (browser), compresi i valori assoluti di schermo (screenLeft, screenTop). Il campo scaleFactor indica il fattore DPI del monitor. Questo endpoint è fondamentale per convertire coordinate relative al browser in coordinate assolute di schermo da usare con gli endpoint OS mouse, in modo che le automazioni funzionino correttamente indipendentemente da dove è posizionata la finestra di JuliuS sul desktop.
sync

Struttura risposta JSON

{ "mainForm": { "left": 100, "top": 50, "width": 1200, "height": 800 }, "browser": { "left": 0, "top": 60, "width": 1024, "height": 768, "screenLeft": 100, "screenTop": 110, "clientWidth": 1024, "clientHeight": 768 }, "scaleFactor": 1.25 }
200JSON con mainForm, browser e scaleFactor — application/json; charset=utf-8
200*{"error":"..."}
Uso tipico: Chiamare questo endpoint una volta prima di una sequenza di click OS per ricavare browser.screenLeft e browser.screenTop, poi sommarli alle coordinate relative del browser per ottenere le coordinate assolute di schermo da passare a osmousemoveclick.

Browser Move Click

GET/?operation=browsermoveclick&x={x}&y={y}Click OS a coordinate relative al pannello browser
Esegue un click sinistro a livello sistema operativo usando coordinate relative al pannello browser CEF (stessa origine di snapshot e MOUSE_CLICK), delegando internamente a ClickOnBrowserRelative la conversione in coordinate assolute di schermo. È più affidabile di osmousemoveclick con coordinate assolute perché funziona correttamente indipendentemente dalla posizione della finestra JuliuS sul desktop e dal fattore di scala DPI, senza che il chiamante debba calcolare la conversione manualmente.
syncOS
ParametroDescrizione
xCoordinata X in pixel CSS relativa all'angolo superiore sinistro del pannello browser
yCoordinata Y in pixel CSS relativa all'angolo superiore sinistro del pannello browser
200clicked_at_browser_320_240 — conferma con le coordinate usate
200*ERROR: ...
# Click a X=320, Y=240 relativi al browser GET /?operation=browsermoveclick&x=320&y=240 HTTP/1.1
Differenza rispetto a click CEF e osmousemoveclick: ?operation=click invia un evento sintetico CEF interno. osmousemoveclick usa coordinate assolute di schermo. browsermoveclick usa coordinate relative al browser ma agisce a livello SO — è il punto di equilibrio tra semplicità d'uso e affidabilità cross-posizione.

Rewrite Variabili Globali

POST/?globalv=rewriteSovrascrive le variabili globali dello script corrente
Invia un nuovo set di variabili globali nel body POST e le inietta direttamente nel blocco GLOBALV dello script attualmente caricato, sovrascrivendo i valori precedenti. Il contenuto viene caricato in frmScript.GlobalV tramite LoadFromStream e poi updateGlobalV aggiorna fisicamente le righe del blocco GLOBALV=BEGIN/END nell'editor. Utile nei sistemi di orchestrazione per parametrizzare uno script già caricato con dati diversi (es. cliente diverso, pratica diversa) senza ricaricare l'intero file. Il body deve contenere coppie var nome="valore"; nel formato del blocco GLOBALV.
async
POST /?globalv=rewrite HTTP/1.1 Content-Type: text/plain var USERNAME="mario.rossi"; var TARGET_URL="https://example.com/dashboard"; var MAX_RETRIES="3";