⌨️Riferimento della riga di comando

maxxing è installato in /usr/local/bin. Esegui maxxing <command> --help per vedere tutte le opzioni.

Server e configurazione

Comando	Scopo
`maxxing serve [--host IP] [--port N]`	avvia il server web (usato dal servizio `claude-maxxing`)
`maxxing setup-link [--reset]`	mostra il link di configurazione monouso; `--reset` dimentica la password e riavvia la configurazione
`maxxing password`	imposta una nuova password per l'interfaccia (interattivo)
`maxxing 2fa status\\|off\\|forget-browsers`	accesso in due passaggi con Telegram: stato, disattivazione (la via per rientrare quando Telegram non risponde), obbligo per ogni browser di chiedere di nuovo il codice
`maxxing status [--json]`	versione, URL, servizio, autenticazione Claude, Telegram, backup, percorsi
`maxxing doctor [--json] [--live] [--offline] [--deps]`	controlla l'installazione; `--live` fa una vera chiamata a Claude, `--offline` salta i controlli degli aggiornamenti (GitHub, release di Claude Code), `--deps` cerca anche le vulnerabilità note dei pacchetti installati (osv.dev)
`maxxing harden [--undo] [--no-restart]`	applica (o rimuove) la sandbox systemd del servizio, poi lo riavvia; ripristina le impostazioni precedenti se il servizio non riparte (vedi Sicurezza)

maxxing init

Crea o aggiorna la configurazione, lo spazio di lavoro, le skill e i job predefiniti. Puoi eseguirlo di nuovo senza rischi: i valori e i file esistenti vengono mantenuti, a meno che tu non passi un'opzione. I modelli dello spazio di lavoro (progetti predefiniti general, system, tutorial) vengono copiati solo se mancano, e un progetto o un topic predefinito che hai eliminato non viene mai ricreato. I job predefiniti vengono creati una sola volta ciascuno (Compattazione della memoria, Controllo aggiornamenti, Attività del mattino e Promemoria di rinnovo disattivati).

Opzione	Effetto
`--workspace PATH`	cartella dello spazio di lavoro (predefinita `/root/maxxing`)
`--files-root PATH`	radice della pagina File (predefinita: la cartella home)
`--port N`	porta HTTP (predefinita 8787)
`--bind IP`	`127.0.0.1` o l'IP Tailscale; gli indirizzi pubblici vengono rifiutati
`--public-url URL`	ad esempio `https://ui.example.com`; `""` lo cancella
`--timezone TZ`	nome IANA (predefinito: il fuso del sistema). Tienilo uguale al fuso del sistema (`timedatectl`), che è quello usato da cron, a meno che tu non mantenga l'orologio del server
`--system-clock follow\\|keep`	`follow`: cambiando il fuso orario nell'interfaccia cambia anche quello del sistema; `keep`: non lo tocca mai (server condiviso), i job controllano la loro pianificazione nel tuo fuso
`--claude-dir PATH`	cartella di Claude Code per Harness Maxxing (predefinita `~/.claude`; `""` = torna a quella). Un'altra cartella lo tiene separato da un Claude Code già usato sul server (passata alle sessioni come `CLAUDE_CONFIG_DIR`)
`--language en\\|fr`	lingua dell'interfaccia
`--secret-from-stdin NAME`	salva un segreto letto da stdin: `claude_oauth_token`, `anthropic_api_key`, `github_update_token`
`--no-crons`	non crea i job predefiniti
`--quiet`, `--json`	controllo dell'output

Esempio: printf %s "$TOKEN" | maxxing init --quiet --secret-from-stdin claude_oauth_token.

Riavvia il servizio dopo aver cambiato la porta, l'indirizzo di bind o l'URL pubblico: systemctl restart claude-maxxing.

maxxing update

Opzione	Effetto
(nessuna)	scarica la nuova versione, riapplica le tue personalizzazioni sopra, sincronizza le dipendenze, aggiorna skill e modelli, riavvia, verifica che il servizio risponda (altrimenti torna indietro), mostra il changelog. Codici di uscita: `0` fatto, `3` conflitto tra le personalizzazioni (nulla è cambiato: adattale, poi usa `--resume`), `4` ripristino della versione precedente, `1` altro errore
`--resume`	termina un aggiornamento dopo che le personalizzazioni sono state adattate a mano (rebase completato)
`--rollback`	torna al codice che girava prima dell'ultimo aggiornamento (si rifiuta, senza cambiare nulla, finché la cartella del codice ha modifiche non salvate)
`--branch B`	passa al branch `B` e lo segue
`--check`	solo verifica: versione installata e ultima versione, con le righe del changelog intermedie. Non cambia nulla; codice di uscita 0 che un aggiornamento esista o no, 1 solo se la verifica fallisce
`--check --notify`	invia anche un messaggio Telegram (thread Crons) quando è disponibile un aggiornamento; non succede nulla se Telegram non è configurato. Usato dal job settimanale "Controllo aggiornamenti"
`--check --json`	risultato leggibile da una macchina `{ok, current, latest, behind, available, changelog, ...}`
`--no-restart`	non riavvia il servizio
`--preflight`	simula l'aggiornamento su una copia usa e getta: per ogni personalizzazione si riporta / su codice cambiato / ora inclusa / va in conflitto, più le modifiche non salvate, le modifiche fatte dall'interfaccia web, le estensioni che la nuova versione non supporta, le note di aggiornamento da applicare e un verdetto (`simple` o `adapt`). Non cambia nulla; `--json` per un output leggibile da una macchina
`--verify`	controlla che ogni estensione si carichi e ogni widget risponda, ed esegue la verifica di ogni personalizzazione. Uscita `0` tutto funziona, `1` c'è qualcosa da sistemare
`--smart`	usato dal pulsante Aggiorna: dopo il riavvio il server apre una sessione `system/harness` che applica le note di aggiornamento

Ogni installazione scarica la nuova versione dal suo remote git (un fork privato o un mirror: con il token di lettura salvato come github_update_token). Un server installato con una chiave prima della 2.0.0a87 passa da solo al repository git pubblico (vedi Licenza). Dopo un aggiornamento, il comando elenca le note di aggiornamento dello spazio di lavoro delle versioni installate (<code>/docs/upgrade/<version>.md): istruzioni per Claude per adattare il tuo spazio di lavoro. La strada più semplice è il topic system/harness (system/update sui server più vecchi): scrivi "aggiorna" e Claude controlla, spiega, aggiorna dopo il tuo sì, poi applica queste note.

Solo aggiornamenti firmati (facoltativo). Imposta "update_verify_signature": true in /var/lib/claude-maxxing/config.json e maxxing update installerà una nuova versione solo se il suo commit, o un tag che punta a esso, ha una firma valida di una chiave di cui git si fida su questo server (git verify-commit / git verify-tag: importa la chiave GPG del maintainer con gpg --import, oppure punta gpg.ssh.allowedSignersFile alla sua chiave SSH). In caso contrario l'aggiornamento si ferma prima di cambiare qualsiasi cosa (codice di uscita 1, un avviso nel feed delle notifiche e su Telegram) e la versione attuale continua a funzionare. maxxing doctor indica se l'ultima versione scaricata supera la verifica. Disattivato per impostazione predefinita.

maxxing license

Comando	Effetto
`maxxing license status [--json]`	la chiave Enterprise facoltativa di questo server (tipo, email, data di fine) e da dove arrivano gli aggiornamenti
`maxxing license activate [HM-…]`	registra una chiave Enterprise, verificata dal server delle licenze (richiesta in modo nascosto; `--key-from-stdin` la legge da stdin)
`maxxing license remove`	dimentica la chiave e libera il suo posto sulla licenza
`maxxing license release`	libera il posto della chiave senza dimenticarla

Vedi Licenza.

maxxing video, maxxing pdf

Comando	Effetto
`maxxing video new DIR`	crea un progetto Remotion in DIR (node_modules collegato all'installazione condivisa)
`maxxing video status`	Node.js, Remotion e il browser headless su questo server (uscita 1 se non è pronto)
`maxxing pdf IN.html OUT.pdf`	stampa in PDF un file HTML o un URL `https://` (A4, con gli sfondi)
`scrapling extract get\\|fetch\\|stealthy-fetch URL OUT.md`	scarica una pagina (HTTP / browser / browser stealth) in Markdown, testo o HTML
`scrapling-python SCRIPT.py`	esegue uno script di scraping con Scrapling e il suo browser
`bash /opt/claude-maxxing/install.sh --tools`	(re)installa Node.js, Chromium, Remotion e Scrapling (= `maxxing deps update`)

maxxing import

Comando	Effetto
`maxxing import --prompt [hermes\\|claude-code\\|openclaw\\|other]`	mostra il prompt da dare al tuo vecchio agente
`maxxing import ZIP --dry-run [--json]`	mostra cosa verrebbe importato
`maxxing import ZIP [--json]`	lo importa (nulla viene sovrascritto; vedi Importazione)

maxxing custom

Le modifiche apportate al codice del prodotto, registrate in modo che gli aggiornamenti le riportino (vedi Personalizzazione).

Comando	Effetto
`maxxing custom` / `status [--json]`	personalizzazioni, modifiche non salvate nella cartella del codice, aggiornamento in sospeso
`maxxing custom save "TITLE" --why "REASON" [--files F…] [--check "CMD"]`	registra con un commit le modifiche non ancora salvate come un'unica personalizzazione (rifiutato sotto `web/`); `--check` = un comando che riesce finché tutto funziona, eseguito dopo ogni aggiornamento
`maxxing custom check ID "CMD"`	imposta la verifica di una personalizzazione (o la cancella con `""`)
`maxxing custom drop ID`	rimuove una personalizzazione
`maxxing custom export`	riscrive `<workspace>/CUSTOMIZATIONS.md` e `customizations/*.patch`
`maxxing custom restore [--from DIR]`	riapplica le patch salvate (nuovo server)

maxxing deps

I componenti esterni (server/maxxing/deps.toml: uv, Python, Node.js, Claude Code, Caddy, Scrapling, Chromium, Remotion, i modelli Whisper, Garage). Come root.

Comando	Effetto
`maxxing deps list [--json]`	versione installata e attesa di ciascuno (uscita 1 se uno manca o è obsoleto)
`maxxing deps verify [NAME...]`	checksum dei binari installati, file non di proprietà di root o scrivibili da altri
`maxxing deps update [NAME...] [--notify]`	installa le versioni fissate accanto a quelle vecchie, passa a quelle nuove quando funzionano (lo fa ogni `maxxing update`)
`maxxing deps remove NAME [--force]`	elimina ciò che il manifest elenca per quel componente (`--force` per uv, Python, Claude Code)
`maxxing deps clean [--dry-run] [--caches]`	vecchie versioni, browser inutilizzati, residui, log troppo grandi (job settimanale); `--caches` svuota anche le cache uv / npm / pip / npx di root, condivise con gli altri strumenti del server
`maxxing deps check [--notify]`	vulnerabilità note (osv.dev) nei lockfile e nei componenti (job settimanale, notifica)

maxxing uninstall

Opzione	Effetto
(nessuna)	rimuove il servizio, il sito Caddy, il blocco crontab gestito, le skill del prodotto e `/usr/local/bin/maxxing`; mantiene codice, stato e spazio di lavoro
`--purge`	elimina anche il codice (`/opt/claude-maxxing`), lo stato (`/var/lib/claude-maxxing`) e i componenti esterni di `deps.toml` (uv, Node.js, gli strumenti; Claude Code e Caddy se li ha installati l'installer; il suo file di swap)
`--purge-workspace`	elimina anche lo spazio di lavoro (irreversibile)
`--yes`	non chiede conferma

Job pianificati

Comando	Scopo
`maxxing cron list`	job, pianificazioni, ultimi risultati
`maxxing cron run <id>`	esegue un job subito nel tuo terminale e aspetta che finisca; `--detach` lo avvia nella sua unità systemd con i limiti di memoria e restituisce subito il controllo (quello che chiama il crontab); `--if-due` lo esegue solo se la sua pianificazione corrisponde a ora nel tuo fuso (orologio del server mantenuto)
`maxxing cron sync`	riscrive il blocco crontab gestito a partire dall'elenco dei job

Feed delle notifiche

Comando	Scopo
`maxxing feed post "Title" [--body] [--level info\\|success\\|warning\\|error] [--source NAME] [--url] [--dedupe KEY] [--group KEY] [--quiet] [--json]`	aggiunge un evento (dashboard, e Telegram secondo la regola della fonte); `--dedupe` ignora una ripetizione, `--group` raggruppa le ripetizioni
`maxxing feed list [--unread] [--source] [--limit] [--json]`	ultimi eventi
`maxxing feed read-all`	segna tutto come letto
`maxxing packs list [--json]`	progetti iniziali e se sono installati
`maxxing packs add ID [ID...] [--json]`	aggiunge progetti iniziali (non sovrascrive mai: vengono aggiunti solo i file mancanti; job creati disattivati)

Chiavi

Comando	Scopo
`maxxing keys list [--json]`	nomi, note e se ogni chiave è esposta (mai i valori)
`maxxing keys get NAME`	mostra un valore (codice di uscita 1 se manca)
`printf %s "$VALUE" \\| maxxing keys set NAME [--note TEXT] [--no-expose]`	crea o aggiorna una chiave; il valore arriva da stdin, mai dalla riga di comando. Una nuova chiave è esposta (variabile d'ambiente di ogni sessione e job shell) a meno di `--no-expose`; un aggiornamento mantiene la sua nota e la sua esposizione
`maxxing keys delete NAME`	rimuove una chiave
`maxxing infra status` / `infra list [--kind K] [--json]`	l'inventario Infra: fonti, problemi, ogni sito / database / bucket / dominio / server (ultimo snapshot)
`maxxing infra refresh`	legge tutto subito (questo server, altri server via SSH, Cloudflare, Hostinger, controlli degli URL)
`maxxing infra site add NAME (--dir D \\| --port N) [--host H] [--dns] [--project P]`	mette online un sito: `https://<indirizzo di Harness>/<NAME>/` (in sandbox) o un host proprio; `site remove`, `site list`, `reserved`
`maxxing infra db install` / `db create NAME` / `db sqlite PATH` / `db backup`	PostgreSQL su localhost, un database + utente per app (URL nel vault come `DB_<NAME>_URL`), backup notturni
`maxxing infra bucket install` / `bucket create NAME [--public]`	bucket S3 su questo server (Garage), chiavi nel vault come `S3_<NAME>_*`
`maxxing infra server add NAME HOST [--user U] [--key K]`	legge un altro server via SSH (`server remove`, `server list`)
`maxxing infra annotate ID [--project P] [--note T] [--hide\\|--show]`	associa una risorsa a un progetto, la annota, la nasconde

Gli script leggono le chiavi dall'ambiente (os.environ["NAME"], $NAME); uno script che rinnova un token (un token di negozio valido 24 ore, un segreto di webhook appena creato) lo riscrive con maxxing keys set.

Server MCP

Comando	Scopo
`maxxing mcp list [--json] [--no-check]`	ogni server MCP di Claude Code, dove si applica e il suo stato (interroga prima Claude Code, qualche secondo)
`maxxing mcp add NAME URL [--where projects/P/topics/T] [--header 'Name: value'] [--sse]`	aggiunge un server tramite indirizzo, per ogni sessione o per un solo topic; segreti come `${KEY}` dal vault
`maxxing mcp add NAME --command 'npx -y pkg' [--env KEY=VALUE] [--where …]`	aggiunge un programma locale
`maxxing mcp remove NAME [--where …]`	lo rimuove

Gli accessi OAuth (stato "Da connettere") si fanno in Impostazioni -> MCP -> Connetti. Vedi Server MCP.

Memoria e sessioni

Comando	Scopo
`maxxing memory [--json]`	ogni memory.md con il suo numero di righe e il limite di righe (Impostazioni -> Memoria)
`maxxing sessions compact-logs [--dry-run]`	accorcia gli output degli strumenti nei log delle sessioni esistenti ed elimina i voluminosi elenchi di avvio di Claude e le righe di avanzamento (libera spazio su disco; `--dry-run` mostra solo quanto si risparmierebbe)
`maxxing sessions token-report [--days N] [--json]`	dove vanno i token delle tue sessioni, letto dalle trascrizioni di Claude Code: dimensione del contesto per chiamata, cache riscritta dopo un'ora di inattività o un cambio di modello, gli strumenti i cui output riempiono il contesto, e quanto avrebbe fatto risparmiare sulle stesse chiamate la compattazione automatica a 400k / 300k / 250k / 200k

Backup

Comando	Scopo
`maxxing backup status [--json]`	configurazione e ultima esecuzione
`maxxing backup run`	esegue subito il backup (codice di uscita 2 se è stato trovato un segreto)
`maxxing backup restore [--ref COMMIT]`	ripristina i file in whitelist
`maxxing backup restore --from OWNER/NAME [--token T]`	nuovo server: configura un repository di backup esistente, poi ripristina (token anche da `$MAXXING_GITHUB_TOKEN`)

Comando	Scopo
`maxxing telegram status [--json]`	bot, chat, thread, impostazioni, ultimo errore
`maxxing telegram test`	invia un messaggio di prova
`maxxing voice status [--json]`	messaggi vocali: motore, modello, stato di preparazione
`maxxing voice set [--engine] [--model] [--language]`	cambia le impostazioni vocali
`maxxing voice download [model]`	scarica un modello vocale locale
`maxxing voice transcribe <file>`	trascrive un file audio con il motore configurato

Installer

curl -fsSL https://get.harness-maxxing.com | bash          # install / repair (from the public git repository, no key)
bash /opt/claude-maxxing/install.sh --update                # = maxxing update
bash /opt/claude-maxxing/install.sh --uninstall [--purge] [--purge-workspace]
bash /opt/claude-maxxing/install.sh --tools                 # (re)install Node.js, Chromium, Remotion, Scrapling (= maxxing deps update)
SOURCE_DIR=/path/to/copy bash /path/to/copy/install.sh      # install a local copy of the code (no download)
bash /opt/claude-maxxing/install.sh --secure                # security updates, fail2ban, firewall (FIREWALL=0: no firewall)
curl -fsSL https://get.harness-maxxing.com | bash -s -- --check   # look at the server first, change nothing

Variabili: vedi Installazione.

Variabili d'ambiente

Variabile	Uso
`MAXXING_STATE`	cartella dello stato (predefinita `/var/lib/claude-maxxing`); impostata dal servizio e dal wrapper della CLI
`MAXXING_GITHUB_TOKEN`	token per `maxxing backup restore --from`
`NO_COLOR`	output semplice