Notiamo può avviare un agente IA sui commenti e sulle attività aperti di un progetto. L’agente fa le modifiche e una persona del Suo team le approva. Un’esecuzione può avvenire sui server di Notiamo o su un computer di Sua proprietà. Questa pagina riguarda il secondo modo: il runner, un piccolo programma che Lei installa sul Suo computer. È per il team dell’agenzia.
Cos’è il runner
Il runner attende le esecuzioni dell’agente che la Sua organizzazione mette in coda in Notiamo. Per ogni esecuzione clona il repository (o si collega al sito WordPress), avvia Claude Code con le istruzioni dell’esecuzione, invia a Notiamo ciò che fa l’agente e segnala quando finisce.
- Non conserva alcuna credenziale di Claude. Avvia il programma
claudegià presente sul computer. Le sessioni del runner usano una propria cartella di configurazione, quindi restano separate dalle Sue. L’accesso in sé è di Claude Code, che lo conserva. - Non è un accesso a Claude dentro Notiamo. Notiamo non vede mai né usa il Suo account Claude. Il runner si limita a eseguire il Suo Claude Code, sul Suo computer, per il Suo lavoro.
Lo installi
Le serve:
- Node.js 22 o successivo;
- Claude Code 2.1.314 o più recente;
- git 2.31 o più recente;
- su Linux e WSL2:
bubblewrapesocat(Debian o Ubuntu:sudo apt install bubblewrap socat). Su macOS non c’è nient’altro da installare.
Poi:
- In Notiamo, apra Impostazioni › Esecuzioni dell’agente. Nella scheda Runner, prema Nuovo runner e gli dia un nome. Copi il token. Viene mostrato una sola volta.
- Sul computer, esegua:
npx @notiamo/runner init
- Incolli il token.
initcontrolla che Claude Code funzioni, esegue l’accesso di Claude Code per il runner, poi installa il servizio e lo avvia. - Sul progetto, imposti Dove viene eseguito l’agente su Computer proprio.
Quando init finisce, il runner è in funzione. Riparte da solo dopo un accesso o un riavvio.
Comandi
| Comando | Cosa fa |
|---|---|
npx @notiamo/runner init |
Configura il runner: token, accesso a Claude Code, installazione e avvio del servizio. |
npx @notiamo/runner@latest update |
Porta il runner alla versione più recente. Il token, il nome e l’accesso restano. |
npx @notiamo/runner status |
Dice se il servizio è installato e in funzione, e mostra l’ultima riga del log. |
npx @notiamo/runner logs |
Mostra le ultime 50 righe del log. |
npx @notiamo/runner stop |
Ferma il servizio fino al prossimo accesso o avvio. |
npx @notiamo/runner uninstall |
Rimuove il servizio. La cartella del runner resta. |
npx @notiamo/runner env <projectId> |
Crea o mostra il file di ambiente che questo computer dà alle esecuzioni di un progetto. |
npx @notiamo/runner start |
Viene eseguito in primo piano. Il servizio esegue questo comando; raramente Le serve. |
Il servizio è un agente launchd com.notiamo.runner su macOS, un’attività pianificata «Notiamo runner» su Windows e un’unità utente systemd notiamo-runner su Linux.
Due runner su un solo computer
npx @notiamo/runner init --profile staging configura un secondo runner, separato. Ha una propria cartella (~/.notiamo-runner/profiles/staging) e un proprio servizio. Aggiunga --profile staging a ogni comando di quel runner. Il nome di un profilo ha lettere, cifre e trattini, da 1 a 32 caratteri.
Cosa può e cosa non può toccare l’agente
Ogni esecuzione riceve un proprio file di impostazioni di Claude Code. Tre cose tengono l’agente al suo posto.
Gli strumenti per i file restano nella cartella dell’esecuzione. Gli strumenti per i file di Claude (leggere, modificare, scrivere, cercare) rifiutano tutto ciò che sta fuori dalla cartella dell’esecuzione. Qualsiasi chiamata che chiederebbe un permesso viene rifiutata, perché non c’è nessuno che risponda.
I comandi della shell vengono eseguiti nella sandbox del sistema operativo. Su macOS (Seatbelt) e su Linux o WSL2 (bubblewrap e socat), ogni comando che l’agente esegue in una shell è confinato. Se la sandbox non riesce ad avviarsi, l’esecuzione non parte.
Nessuna credenziale del computer arriva all’agente. Claude Code riceve solo un breve elenco di variabili d’ambiente (PATH, HOME, USER, LOGNAME, SHELL, LANG, LC_ALL, LC_CTYPE, TERM, TMPDIR, TZ, XDG_*, le impostazioni di proxy e certificati) più quelle proprie dell’esecuzione. Non riceve mai SSH_AUTH_SOCK, GH_TOKEN, GITHUB_TOKEN, NPM_TOKEN, AWS_* né ANTHROPIC_*. Il git dell’agente non vede alcuna configurazione git globale o di sistema.
Cosa la sandbox della shell consente e nega:
- Letture negate: le cartelle degli altri progetti (comprese quelle delle altre esecuzioni nello stesso momento), i file del runner stesso e i Suoi file e cartelle di credenziali (chiavi SSH, accessi al cloud, accessi ai registri dei pacchetti, credenziali git).
- Scritture consentite: solo nella cartella dell’esecuzione e nella cartella della cache dei pacchetti del progetto, accanto ad essa.
.git/hookse.git/configdell’esecuzione sono di sola lettura. - Rete consentita: GitHub, npm, Notiamo, il sito WordPress (per un’esecuzione WordPress) e gli host che aggiunge in Host aggiuntivi raggiungibili dall’agente nella scheda Runner. Tutto il resto è rifiutato.
L’agente non fa mai push e non conserva credenziali. Il runner fa il push del ramo dell’esecuzione da sé, dopo il lavoro dell’agente.
Quando un’esecuzione finisce, il runner ferma tutti i processi che l’agente ha lasciato, come un server di sviluppo.
Il portachiavi su macOS
La sandbox di macOS non chiude del tutto il portachiavi. Quindi non tenga alcun accesso a GitHub nel portachiavi dell’utente che esegue il runner (init avvisa quando ne trova uno). La configurazione più sicura è un utente macOS dedicato, con un proprio portachiavi.
Windows
Windows da solo non ha una sandbox per la shell. Il testo di un commento potrebbe quindi far eseguire qualsiasi comando a Suo nome. Esegua il runner dentro WSL2. Su Windows da solo il runner non parte, a meno che non aggiunga "allowUnsandboxed": true al suo config.json; lo faccia solo su una macchina che non contiene nient’altro.
Più esecuzioni contemporaneamente
Nella scheda Runner imposta Esecuzioni contemporanee: da 1 a 3. Ogni esecuzione usa il Suo piano Claude, quindi tenga il numero entro ciò che il piano può sostenere. Un progetto non viene mai eseguito due volte nello stesso momento: una seconda esecuzione sullo stesso progetto aspetta la prima.
Ogni esecuzione contemporanea ha una propria cartella di slot. La sandbox di un’esecuzione non può leggere gli altri slot.
Un runner per un solo cliente
Quando crea un runner, può limitarlo a uno spazio di lavoro in Esegue per. Allora prende solo le esecuzioni di quel cliente. Per configurarlo sul computer del cliente: installi lì Claude Code, esegua npx @notiamo/runner init e incolli il token del runner. L’accesso a Claude di quel computer paga le esecuzioni, quindi acceda con l’account che deve pagare.
Comandi di preparazione e di test
Un clone pulito non ha pacchetti installati. Dica all’agente come installarli e come fare i test. Apra le impostazioni dell’agente del progetto e compili Comando di preparazione e Comando di test, una riga ciascuno.
- L’agente esegue il comando di preparazione una volta, prima della sua prima modifica. Esempio:
pnpm install --frozen-lockfile. - L’agente esegue il comando di test prima di ogni commit. Una modifica che non lo supera viene corretta o annullata. Esempio:
pnpm typecheck && pnpm lint. - L’agente esegue entrambi da sé, nella stessa sandbox degli altri suoi comandi. Il registro dei pacchetti deve essere tra gli host consentiti. GitHub e
registry.npmjs.orgci sono di default. Aggiunga qualsiasi altro (PyPI, crates.io, un registro privato) in Host aggiuntivi raggiungibili dall’agente nella scheda Runner. - Ogni progetto ha una cartella della cache dei pacchetti accanto al suo clone. npm, pnpm, Yarn, Corepack, Bun, pip, uv e Composer vi tengono le loro cache, perché la sandbox chiude i soliti posti nella Sua cartella personale. La cartella resta tra le esecuzioni del progetto e sparisce con il clone. Non esiste su Windows da solo.
- Tenga leggero il comando di test. Un test che richiede Docker non può essere eseguito. Un test che richiede un database può essere eseguito solo quando il file di ambiente del progetto punta a uno che Lei tiene in funzione (vedere sotto).
L’agente fa i commit come «Notiamo agent», una riga semplice per voce. Il runner disattiva la riga «Co-Authored-By» e la dicitura «Generated with» di Claude Code, quindi il repository non mostra alcun coautore IA.
Un ambiente per i Suoi progetti
Un’esecuzione su un progetto GitHub riceve un clone pulito e nient’altro. Per un progetto software Suo, i test possono richiedere anche un database, un archivio di file, un ricevitore di email e un .env. Il computer del runner li dà alle esecuzioni di un progetto con un semplice file:
npx @notiamo/runner env <projectId>
<projectId> è l’ultima parte dell’indirizzo della pagina del progetto in Notiamo. Il comando crea ~/.notiamo-runner/env/<projectId>.env, leggibile solo da Lei, e stampa il percorso. Metta un KEY=VALUE per riga. La prossima esecuzione di quel progetto riceve le variabili nella sua shell, e all’agente vengono detti i loro nomi, mai i valori. Rimuova il file per toglierle. Il file non lascia mai il computer: Notiamo non sa che esiste.
Con il file presente, la shell dell’esecuzione può raggiungere anche servizi su 127.0.0.1 su macOS: il Suo Postgres, un archivio di file, un server di sviluppo. Li tiene in funzione Lei; l’agente non può avviarli, e Docker resta fuori dalla sua portata. Su Linux la sandbox ha una propria rete, quindi lì 127.0.0.1 non è quello del computer: colleghi i servizi all’indirizzo di rete del computer e aggiunga quell’host in Host aggiuntivi raggiungibili dall’agente.
Regole:
- Solo valori di sviluppo e di test. L’agente esegue comandi di shell e può leggere ogni variabile. Mai una chiave di produzione, mai una password che usa altrove.
PATH,HOME, le variabili di proxy e certificati,NODE_OPTIONS,NODE_TLS_REJECT_UNAUTHORIZED,NOTIAMO_*,GIT_*,CLAUDE_*eANTHROPIC_*vengono ignorati, e il log lo dice. Il file può cambiare ciò che vedono i comandi dell’agente, mai il modo in cui Claude Code parla con Anthropic e con Notiamo.- I valori di 6 caratteri o più sono mascherati come
[secret]nella trascrizione che Notiamo riceve. I valori brevi (1,true) no. - Tenga Esecuzioni contemporanee a 1 quando i progetti di un runner condividono un database tramite il loro file di ambiente. Due esecuzioni nello stesso momento farebbero i loro test sullo stesso database.
Siti WordPress
La connessione si trova nella scheda Accesso al sito del progetto: una password per le applicazioni e, facoltativamente, SSH o FTP. Il runner ricorda la chiave del server SSH alla prima visita e rifiuta un server che in seguito mostra un’altra chiave. Un’esecuzione procede così:
- Backup prima. Con SSH il runner esporta il database e lo carica su Notiamo, compresso, al massimo 200 MB. Notiamo lo conserva per 30 giorni. Con FTP o con la sola API non c’è backup.
- L’agente lavora secondo l’elenco di comandi consentiti qui sotto.
- Controllo del sito dopo. Il runner apre il sito e verifica che risponda ancora.
- Ripristino in caso di errore. Se il controllo fallisce, il runner ripristina il database.
Cosa può eseguire l’agente con wp-cli, per gruppo (impostato sul progetto):
- Contenuti:
post *,term *,menu *,media import,option get,option update. - Database:
search-replace(solo il testo vecchio e quello nuovo; non tocca mai le tabelle degli utenti né delle opzioni),cache flush,rewrite flush,transient delete. - Plugin e temi:
pluginethemeconlist,activate,deactivate,update. - Informazioni:
core version,site list,db size. - File: nessun comando wp-cli; l’agente usa i suoi strumenti per i file. Scrivono stili, script e altri file che il server non esegue.
- File PHP (disattivato per impostazione predefinita): gli strumenti per i file possono scrivere anche PHP. Un file PHP è codice che gira sul Suo server, e un’esecuzione WordPress non ha una fase di approvazione: la modifica è subito online. Lo attivi solo per un sito in cui si fida di tutte le persone che possono scrivere un commento.
- Mai, a meno che scelga «Consenti tutto»:
eval,eval-file,shell,user *,db query|import|reset|drop|export,plugin install,theme install,core update|download.
Cosa è salvato dove
Tutto si trova in ~/.notiamo-runner.
| Percorso | Cosa contiene |
|---|---|
config.json |
L’indirizzo di Notiamo, il nome del runner e il token del runner. Leggibile solo da Lei. |
claude/ |
La cartella di configurazione di Claude Code per il runner: il suo accesso e le sue sessioni. |
projects/ |
Le copie di lavoro dei Suoi progetti, una cartella per progetto in ogni slot. Un progetto non usato per il numero di giorni impostato nella scheda Runner viene rimosso; la prossima esecuzione lo clona di nuovo. |
git/ |
Le copie proprie del runner dei Suoi repository. L’agente non può né leggere né scrivere questa cartella. |
env/ |
I file di ambiente che ha creato, uno per progetto. |
runs/ |
Le impostazioni di Claude Code di ogni esecuzione in corso. Nessun segreto. Cancellata quando l’esecuzione finisce. |
runner.log |
Cosa ha fatto il runner, senza segreti. |
state.json |
Gli id delle esecuzioni in corso. Dopo un riavvio, ciascuna viene segnalata a Notiamo come fallita. |
I segreti di un’esecuzione (le password WordPress, i token propri dell’esecuzione) arrivano da Notiamo insieme all’esecuzione e vivono solo in memoria. L’agente li riceve come variabili d’ambiente, mai in un file. Ciò che l’agente stampa viene ripulito da essi prima che la trascrizione venga caricata.
Il runner non usa mai le credenziali git del computer. Ogni esecuzione riceve da Notiamo un token GitHub che vale un’ora e solo per il repository dell’esecuzione. Il runner lo tiene in memoria e lo usa per il proprio fetch e il proprio push. Notiamo apre e unisce la pull request.
Fermare un runner
Nella scheda Runner, prema Disattiva per mettere in pausa un runner, oppure Elimina per rimuoverlo. Il token di un runner eliminato smette di funzionare subito.