⌨️Référence de la ligne de commande

maxxing est installé dans /usr/local/bin. Lancez maxxing <command> --help pour voir toutes les options.

Serveur et configuration

Commande	Rôle
`maxxing serve [--host IP] [--port N]`	lance le serveur web (utilisé par le service `claude-maxxing`)
`maxxing setup-link [--reset]`	affiche le lien de configuration à usage unique ; `--reset` oublie le mot de passe et recommence la configuration
`maxxing password`	définit un nouveau mot de passe pour l'interface (interactif)
`maxxing 2fa status\\|off\\|forget-browsers`	connexion en deux étapes avec Telegram : état, désactivation (le moyen de revenir quand Telegram ne répond pas), obligation pour chaque navigateur de se ré-authentifier
`maxxing status [--json]`	version, URL, service, authentification Claude, Telegram, sauvegarde, chemins
`maxxing doctor [--json] [--live] [--offline] [--deps]`	vérifie l'installation ; `--live` fait un vrai appel à Claude, `--offline` saute les vérifications de mise à jour (GitHub, version de Claude Code), `--deps` recherche aussi les vulnérabilités connues des paquets installés (osv.dev)
`maxxing harden [--undo] [--no-restart]`	applique (ou retire) le bac à sable systemd du service, puis le redémarre ; rétablit les réglages précédents si le service ne redémarre pas (voir Sécurité)

maxxing init

Crée ou rafraîchit la configuration, l'espace de travail, les skills et les tâches par défaut. Vous pouvez le relancer sans risque : les valeurs et fichiers existants sont conservés, sauf si vous ajoutez une option. Les modèles de l'espace de travail (projets par défaut general, system, tutorial) ne sont copiés que s'ils manquent, et un projet ou un sujet par défaut que vous avez supprimé n'est jamais recréé. Les tâches par défaut sont créées une seule fois chacune (Compactage de la mémoire, Recherche de mises à jour, Tâches du matin et Rappel de renouvellement désactivés).

Option	Effet
`--workspace PATH`	dossier de l'espace de travail (par défaut `/root/maxxing`)
`--files-root PATH`	racine de la page Fichiers (par défaut : le dossier personnel)
`--port N`	port HTTP (par défaut 8787)
`--bind IP`	`127.0.0.1` ou l'IP Tailscale ; les adresses publiques sont refusées
`--public-url URL`	par exemple `https://ui.example.com` ; `""` l'efface
`--timezone TZ`	nom IANA (par défaut : le fuseau du système). Gardez-le identique au fuseau du système (`timedatectl`), celui qu'utilise cron - sauf si l'horloge du serveur est conservée
`--system-clock follow\\|keep`	`follow` : changer le fuseau horaire dans l'interface change aussi le fuseau du système ; `keep` : n'y touche jamais (serveur partagé), les tâches vérifient leur planning dans votre fuseau
`--claude-dir PATH`	dossier de Claude Code pour Harness Maxxing (par défaut `~/.claude` ; `""` = y revenir). Un autre dossier le garde séparé d'un Claude Code déjà utilisé sur le serveur (transmis aux sessions en tant que `CLAUDE_CONFIG_DIR`)
`--language en\\|fr`	langue de l'interface
`--secret-from-stdin NAME`	enregistre un secret lu sur l'entrée standard : `claude_oauth_token`, `anthropic_api_key`, `github_update_token`
`--no-crons`	ne crée pas les tâches par défaut
`--quiet`, `--json`	contrôle de l'affichage

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

Redémarrez le service après avoir changé le port, l'adresse d'écoute ou l'URL publique : systemctl restart claude-maxxing.

maxxing update

Option	Effet
(aucune)	récupère la nouvelle version, rejoue vos personnalisations par-dessus, synchronise les dépendances, rafraîchit les skills et les modèles, redémarre, vérifie que le service répond (sinon revient en arrière), affiche le journal des modifications. Codes de sortie : `0` terminé, `3` conflit avec les personnalisations (rien n'a changé - adaptez-les, puis `--resume`), `4` retour en arrière effectué, `1` autre erreur
`--resume`	termine une mise à jour après l'adaptation manuelle des personnalisations (rebase terminé)
`--rollback`	revient au code qui tournait avant la dernière mise à jour (refuse, sans rien changer, tant que le dossier du code contient des modifications non enregistrées)
`--branch B`	passe sur la branche `B` et la suit
`--check`	vérifie seulement : version installée et dernière version, avec les lignes du journal des modifications entre les deux. Ne change rien ; code de sortie 0 qu'une mise à jour existe ou non, 1 uniquement si la vérification échoue
`--check --notify`	envoie aussi un message Telegram (fil Crons) quand une mise à jour est disponible ; il ne se passe rien si Telegram n'est pas configuré. Utilisé par la tâche hebdomadaire « Recherche de mises à jour »
`--check --json`	résultat lisible par une machine `{ok, current, latest, behind, available, changelog, ...}`
`--no-restart`	ne redémarre pas le service
`--preflight`	simule la mise à jour sur une copie jetable : pour chaque personnalisation reprise telle quelle / sur du code modifié / désormais incluse / en conflit, plus les modifications non enregistrées, les modifications faites dans l'interface web, les extensions que la nouvelle version ne prend pas en charge, les notes de mise à niveau à appliquer, et un verdict (`simple` ou `adapt`). Ne change rien ; `--json` pour un résultat lisible par une machine
`--verify`	vérifie que chaque extension se charge et que chaque widget répond, et lance la vérification de chaque personnalisation. Code `0` tout fonctionne, `1` il y a quelque chose à corriger
`--smart`	utilisé par le bouton Mettre à jour : après le redémarrage, le serveur ouvre une session `system/harness` qui applique les notes de mise à niveau

Chaque installation récupère la nouvelle version depuis son dépôt git distant (un fork privé ou un miroir : avec le jeton en lecture enregistré sous le nom github_update_token). Un serveur installé avec une clé avant la version 2.0.0a87 passe d'abord tout seul au dépôt git public (voir Licence). Après une mise à jour, la commande affiche les notes de mise à niveau de l'espace de travail des versions installées (<code>/docs/upgrade/<version>.md) : des instructions pour que Claude adapte votre espace de travail. Le plus simple est de passer par le sujet system/harness (system/update sur les anciens serveurs) : dites « mets à jour » et Claude vérifie, explique, met à jour après votre accord, puis applique ces notes.

Mises à jour signées uniquement (facultatif). Définissez "update_verify_signature": true dans /var/lib/claude-maxxing/config.json et maxxing update n'installe une nouvelle version que si son commit, ou un tag qui le désigne, porte une signature valide d'une clé à laquelle git fait confiance sur ce serveur (git verify-commit / git verify-tag : importez la clé GPG du mainteneur avec gpg --import, ou faites pointer gpg.ssh.allowedSignersFile vers sa clé SSH). Sinon, la mise à jour s'arrête avant de rien changer (code de sortie 1, un avertissement dans le flux de notifications et sur Telegram) et la version actuelle continue de tourner. maxxing doctor indique si la dernière version récupérée passe la vérification. Désactivé par défaut.

maxxing license

Commande	Effet
`maxxing license status [--json]`	la clé Enterprise facultative de ce serveur (type, e-mail, date de fin) et l'origine des mises à jour
`maxxing license activate [HM-…]`	enregistre une clé Enterprise, vérifiée par le serveur de licences (saisie masquée ; `--key-from-stdin` la lit sur l'entrée standard)
`maxxing license remove`	oublie la clé et libère sa place sur la licence
`maxxing license release`	libère la place de la clé sans l'oublier

Voir Licence.

maxxing video, maxxing pdf

Commande	Effet
`maxxing video new DIR`	crée un projet Remotion dans DIR (node_modules lié à l'installation partagée)
`maxxing video status`	Node.js, Remotion et le navigateur sans interface sur ce serveur (sortie 1 si ce n'est pas prêt)
`maxxing pdf IN.html OUT.pdf`	imprime un fichier HTML ou une URL `https://` en PDF (A4, avec les arrière-plans)
`scrapling extract get\\|fetch\\|stealthy-fetch URL OUT.md`	récupère une page (HTTP / navigateur / navigateur furtif) en Markdown, en texte ou en HTML
`scrapling-python SCRIPT.py`	lance un script de scraping avec Scrapling et son navigateur
`bash /opt/claude-maxxing/install.sh --tools`	(ré)installe Node.js, Chromium, Remotion et Scrapling (= `maxxing deps update`)

maxxing import

Commande	Effet
`maxxing import --prompt [hermes\\|claude-code\\|openclaw\\|other]`	affiche le prompt à donner à votre ancien agent
`maxxing import ZIP --dry-run [--json]`	montre ce qui serait importé
`maxxing import ZIP [--json]`	l'importe (rien n'est écrasé ; voir Import)

maxxing custom

Les modifications apportées au code du produit, enregistrées pour que les mises à jour les reprennent (voir Personnalisation).

Commande	Effet
`maxxing custom` / `status [--json]`	personnalisations, modifications non enregistrées dans le dossier du code, mise à jour en attente
`maxxing custom save "TITLE" --why "REASON" [--files F…] [--check "CMD"]`	valide les modifications en cours comme une seule personnalisation (refusé sous `web/`) ; `--check` = une commande qui réussit tant que la personnalisation fonctionne, lancée après chaque mise à jour
`maxxing custom check ID "CMD"`	définit (ou efface avec `""`) la vérification d'une personnalisation
`maxxing custom drop ID`	supprime une personnalisation
`maxxing custom export`	réécrit `<workspace>/CUSTOMIZATIONS.md` et `customizations/*.patch`
`maxxing custom restore [--from DIR]`	ré-applique les correctifs enregistrés (nouveau serveur)

maxxing deps

Les composants externes (server/maxxing/deps.toml : uv, Python, Node.js, Claude Code, Caddy, Scrapling, Chromium, Remotion, les modèles Whisper, Garage). En tant que root.

Commande	Effet
`maxxing deps list [--json]`	version installée et version attendue de chacun (sortie 1 si l'un manque ou est périmé)
`maxxing deps verify [NAME...]`	sommes de contrôle des binaires installés, fichiers n'appartenant pas à root ou modifiables par d'autres
`maxxing deps update [NAME...] [--notify]`	installe les versions épinglées à côté des anciennes, bascule une fois qu'elles fonctionnent (chaque `maxxing update` le fait)
`maxxing deps remove NAME [--force]`	supprime ce que le manifeste liste pour lui (`--force` pour uv, Python, Claude Code)
`maxxing deps clean [--dry-run] [--caches]`	anciennes versions, navigateurs inutilisés, restes, journaux trop volumineux (tâche hebdomadaire) ; `--caches` vide aussi les caches uv / npm / pip / npx de root, partagés avec les autres outils du serveur
`maxxing deps check [--notify]`	vulnérabilités connues (osv.dev) dans les fichiers de verrouillage et les composants (tâche hebdomadaire, notification)

maxxing uninstall

Option	Effet
(aucune)	supprime le service, le site Caddy, le bloc crontab géré, les skills du produit et `/usr/local/bin/maxxing` ; conserve le code, l'état et l'espace de travail
`--purge`	supprime aussi le code (`/opt/claude-maxxing`), l'état (`/var/lib/claude-maxxing`) et les composants externes de `deps.toml` (uv, Node.js, les outils ; Claude Code et Caddy quand c'est l'installateur qui les a installés ; son fichier d'échange)
`--purge-workspace`	supprime aussi l'espace de travail (irréversible)
`--yes`	ne demande pas de confirmation

Tâches planifiées

Commande	Rôle
`maxxing cron list`	tâches, plannings, derniers résultats
`maxxing cron run <id>`	lance une tâche tout de suite dans votre terminal et attend sa fin ; `--detach` la démarre dans sa propre unité systemd avec les limites de mémoire et rend la main (ce qu'appelle le crontab) ; `--if-due` ne la lance que si son planning correspond à l'instant présent dans votre fuseau (horloge du serveur conservée)
`maxxing cron sync`	réécrit le bloc crontab géré à partir de la liste des tâches

Flux de notifications

Commande	Rôle
`maxxing feed post "Title" [--body] [--level info\\|success\\|warning\\|error] [--source NAME] [--url] [--dedupe KEY] [--group KEY] [--quiet] [--json]`	ajoute un événement (tableau de bord, et Telegram selon la règle de la source) ; `--dedupe` ignore une répétition, `--group` regroupe les répétitions
`maxxing feed list [--unread] [--source] [--limit] [--json]`	derniers événements
`maxxing feed read-all`	marque tout comme lu
`maxxing packs list [--json]`	projets de démarrage et indication s'ils sont installés
`maxxing packs add ID [ID...] [--json]`	ajoute des projets de démarrage (n'écrase jamais : seuls les fichiers manquants sont ajoutés ; tâches créées désactivées)

Clés

Commande	Rôle
`maxxing keys list [--json]`	noms, notes et indication si chaque clé est exposée (jamais les valeurs)
`maxxing keys get NAME`	affiche une valeur (code de sortie 1 si elle manque)
`printf %s "$VALUE" \\| maxxing keys set NAME [--note TEXT] [--no-expose]`	crée ou met à jour une clé ; la valeur vient de l'entrée standard, jamais de la ligne de commande. Une nouvelle clé est exposée (variable d'environnement de chaque session et de chaque tâche shell) sauf avec `--no-expose` ; une mise à jour conserve sa note et son exposition
`maxxing keys delete NAME`	supprime une clé
`maxxing infra status` / `infra list [--kind K] [--json]`	l'inventaire Infra : sources, problèmes, chaque site / base de données / bucket / domaine / serveur (dernier instantané)
`maxxing infra refresh`	relit tout maintenant (ce serveur, les autres serveurs via SSH, Cloudflare, Hostinger, vérifications d'URL)
`maxxing infra site add NAME (--dir D \\| --port N) [--host H] [--dns] [--project P]`	met un site en ligne : `https://<Harness address>/<NAME>/` (en bac à sable) ou son propre hôte ; `site remove`, `site list`, `reserved`
`maxxing infra db install` / `db create NAME` / `db sqlite PATH` / `db backup`	PostgreSQL en local, une base de données + un utilisateur par application (URL dans le coffre sous `DB_<NAME>_URL`), sauvegardes chaque nuit
`maxxing infra bucket install` / `bucket create NAME [--public]`	buckets S3 sur ce serveur (Garage), clés dans le coffre sous `S3_<NAME>_*`
`maxxing infra server add NAME HOST [--user U] [--key K]`	lit un autre serveur via SSH (`server remove`, `server list`)
`maxxing infra annotate ID [--project P] [--note T] [--hide\\|--show]`	rattache une ressource à un projet, y ajoute une note, la masque

Les scripts lisent les clés dans l'environnement (os.environ["NAME"], $NAME) ; un script qui renouvelle un jeton (un jeton de boutique valable 24 heures, un secret de webhook qu'il vient de créer) le réécrit avec maxxing keys set.

Serveurs MCP

Commande	Rôle
`maxxing mcp list [--json] [--no-check]`	chaque serveur MCP de Claude Code, où il s'applique et son état (interroge d'abord Claude Code, quelques secondes)
`maxxing mcp add NAME URL [--where projects/P/topics/T] [--header 'Name: value'] [--sse]`	ajoute un serveur par son adresse, pour toutes les sessions ou pour un seul sujet ; secrets sous la forme `${KEY}` depuis le coffre
`maxxing mcp add NAME --command 'npx -y pkg' [--env KEY=VALUE] [--where …]`	ajoute un programme local
`maxxing mcp remove NAME [--where …]`	le supprime

Les connexions OAuth (état « À connecter ») se font dans Paramètres -> MCP -> Connecter. Voir Serveurs MCP.

Mémoire et sessions

Commande	Rôle
`maxxing memory [--json]`	chaque memory.md avec son nombre de lignes et la limite de lignes (Paramètres -> Mémoire)
`maxxing sessions compact-logs [--dry-run]`	raccourcit les sorties d'outils des journaux de sessions existants et supprime les longues listes de démarrage de Claude et les lignes de progression (libère de l'espace disque ; `--dry-run` indique seulement ce qui serait économisé)
`maxxing sessions token-report [--days N] [--json]`	où vont les tokens de vos sessions, d'après les transcriptions de Claude Code : taille du contexte à chaque appel, cache réécrit après une heure d'inactivité ou un changement de modèle, les outils dont les sorties remplissent le contexte, et ce qu'aurait économisé un compactage automatique à 400k / 300k / 250k / 200k sur les mêmes appels

Sauvegarde

Commande	Rôle
`maxxing backup status [--json]`	configuration et dernière exécution
`maxxing backup run`	sauvegarde maintenant (code de sortie 2 si un secret a été trouvé)
`maxxing backup restore [--ref COMMIT]`	restaure les fichiers de la liste autorisée
`maxxing backup restore --from OWNER/NAME [--token T]`	nouveau serveur : configure un dépôt de sauvegarde existant, puis restaure (jeton aussi via `$MAXXING_GITHUB_TOKEN`)

Commande	Rôle
`maxxing telegram status [--json]`	bot, conversation, fils, réglages, dernière erreur
`maxxing telegram test`	envoie un message de test
`maxxing voice status [--json]`	messages vocaux : moteur, modèle, état de préparation
`maxxing voice set [--engine] [--model] [--language]`	modifie les réglages vocaux
`maxxing voice download [model]`	télécharge un modèle de reconnaissance vocale local
`maxxing voice transcribe <file>`	transcrit un fichier audio avec le moteur configuré

Installateur

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

Variables : voir Installation.

Variables d'environnement

Variable	Usage
`MAXXING_STATE`	dossier d'état (par défaut `/var/lib/claude-maxxing`) ; défini par le service et par le script d'enveloppe de la CLI
`MAXXING_GITHUB_TOKEN`	jeton pour `maxxing backup restore --from`
`NO_COLOR`	affichage sans couleur