failproofai 0.0.6-beta.2 → 0.0.6-beta.4

package/.next/standalone/docs/it/examples.mdx

@@ -1,307 +0,0 @@
----
-title: Esempi
-description: "Come configurare i hook per Claude Code e l'Agents SDK"
-icon: book-open
----
-
-Esempi pronti all'uso per scenari comuni. Ognuno mostra come installare e cosa aspettarsi.
-
----
-
-## Configurazione dei hook per Claude Code
-
-Failproof AI si integra con Claude Code tramite il suo [sistema di hook](https://docs.anthropic.com/en/docs/claude-code/hooks). Quando esegui `failproofai policies --install`, registra i comandi dei hook in `settings.json` di Claude Code che si attivano ad ogni chiamata di strumento.
-
-<Steps>
-  <Step title="Installa failproofai">
-    ```bash
-    npm install -g failproofai
-    ```
-  </Step>
-  <Step title="Abilita tutte le politiche integrate">
-    ```bash
-    failproofai policies --install
-    ```
-  </Step>
-  <Step title="Verifica che i hook siano registrati">
-    ```bash
-    cat ~/.claude/settings.json | grep failproofai
-    ```
-
-    Dovresti vedere le voci dei hook per gli eventi `PreToolUse`, `PostToolUse`, `Notification` e `Stop`.
-  </Step>
-  <Step title="Esegui Claude Code">
-    ```bash
-    claude
-    ```
-
-    Le politiche ora vengono eseguite automaticamente ad ogni chiamata di strumento. Prova a chiedere a Claude di eseguire `sudo rm -rf /` - verrà bloccato.
-  </Step>
-</Steps>
-
----
-
-## Configurazione dei hook per l'Agents SDK
-
-Se stai costruendo con l'[Agents SDK](https://docs.anthropic.com/en/docs/agents-sdk), puoi usare lo stesso sistema di hook a livello programmatico.
-
-<Steps>
-  <Step title="Installa failproofai nel tuo progetto">
-    ```bash
-    npm install failproofai
-    ```
-  </Step>
-  <Step title="Configura i hook nel tuo agent">
-    Passa i comandi dei hook quando crei il tuo processo di agent. I hook si attivano allo stesso modo di Claude Code - tramite JSON su stdin/stdout:
-
-    ```bash
-    failproofai --hook PreToolUse   # chiamato prima di ogni strumento
-    failproofai --hook PostToolUse  # chiamato dopo ogni strumento
-    ```
-  </Step>
-  <Step title="Scrivi una politica personalizzata per il tuo agent">
-    ```javascript
-    import { customPolicies, allow, deny } from "failproofai";
-
-    customPolicies.add({
-      name: "limit-to-project-dir",
-      description: "Mantieni l'agent all'interno della directory del progetto",
-      match: { events: ["PreToolUse"] },
-      fn: async (ctx) => {
-        const path = String(ctx.toolInput?.file_path ?? "");
-        if (path.startsWith("/") && !path.startsWith(ctx.session?.cwd ?? "")) {
-          return deny("L'agent è limitato alla directory del progetto");
-        }
-        return allow();
-      },
-    });
-    ```
-  </Step>
-  <Step title="Installa la politica personalizzata">
-    ```bash
-    failproofai policies --install --custom ./my-agent-policies.js
-    ```
-  </Step>
-</Steps>
-
----
-
-## Blocca i comandi distruttivi
-
-La configurazione più comune - previeni agli agent di causare danni irreversibili.
-
-```bash
-failproofai policies --install block-sudo block-rm-rf block-force-push block-curl-pipe-sh
-```
-
-Cosa fa:
-- `block-sudo` - blocca tutti i comandi `sudo`
-- `block-rm-rf` - blocca l'eliminazione ricorsiva di file
-- `block-force-push` - blocca `git push --force`
-- `block-curl-pipe-sh` - blocca il piping di script remoti a shell
-
----
-
-## Previeni la perdita di segreti
-
-Impedisci agli agent di visualizzare o perdere credenziali nell'output dello strumento.
-
-```bash
-failproofai policies --install sanitize-api-keys sanitize-jwt sanitize-connection-strings sanitize-bearer-tokens
-```
-
-Questi si attivano su `PostToolUse` - dopo che uno strumento è stato eseguito, ripuliscono l'output prima che l'agent lo veda.
-
----
-
-## Ricevi avvisi Slack quando gli agent hanno bisogno di attenzione
-
-Usa l'hook di notifica per inoltrare gli avvisi di inattività a Slack.
-
-```javascript
-import { customPolicies, allow, instruct } from "failproofai";
-
-customPolicies.add({
-  name: "slack-on-idle",
-  description: "Avvisa Slack quando l'agent è in attesa di input",
-  match: { events: ["Notification"] },
-  fn: async (ctx) => {
-    const webhookUrl = process.env.SLACK_WEBHOOK_URL;
-    if (!webhookUrl) return allow();
-
-    const message = String(ctx.payload?.message ?? "L'agent è in attesa");
-    const project = ctx.session?.cwd ?? "sconosciuto";
-
-    try {
-      await fetch(webhookUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          text: `*${message}*\nProgetto: \`${project}\``,
-        }),
-        signal: AbortSignal.timeout(5000),
-      });
-    } catch {
-      // non bloccare mai l'agent se Slack non è raggiungibile
-    }
-
-    return allow();
-  },
-});
-```
-
-Installalo:
-
-```bash
-SLACK_WEBHOOK_URL=https://hooks.slack.com/... failproofai policies --install --custom ./slack-alerts.js
-```
-
----
-
-## Mantieni gli agent su un branch
-
-Previeni agli agent di cambiare branch o fare push a quelli protetti.
-
-```javascript
-import { customPolicies, allow, deny } from "failproofai";
-
-customPolicies.add({
-  name: "stay-on-branch",
-  description: "Impedisci all'agent di fare checkout di altri branch",
-  match: { events: ["PreToolUse"] },
-  fn: async (ctx) => {
-    if (ctx.toolName !== "Bash") return allow();
-    const cmd = String(ctx.toolInput?.command ?? "");
-    if (/git\s+checkout\s+(?!-b)/.test(cmd)) {
-      return deny("Rimani sul branch corrente. Crea un nuovo branch con -b se necessario.");
-    }
-    return allow();
-  },
-});
-```
-
----
-
-## Richiedi i test prima dei commit
-
-Ricorda agli agent di eseguire i test prima di fare commit.
-
-```javascript
-import { customPolicies, allow, instruct } from "failproofai";
-
-customPolicies.add({
-  name: "test-before-commit",
-  description: "Ricorda all'agent di eseguire i test prima di fare commit",
-  match: { events: ["PreToolUse"] },
-  fn: async (ctx) => {
-    if (ctx.toolName !== "Bash") return allow();
-    const cmd = String(ctx.toolInput?.command ?? "");
-    if (/git\s+commit/.test(cmd)) {
-      return instruct("Esegui i test prima di fare commit. Usa prima `npm test` o `bun test`.");
-    }
-    return allow();
-  },
-});
-```
-
----
-
-## Blocca un repository di produzione
-
-Commit una configurazione a livello di progetto in modo che ogni sviluppatore del tuo team ottenga le stesse politiche.
-
-Crea `.failproofai/policies-config.json` nel tuo repository:
-
-```json
-{
-  "enabledPolicies": [
-    "block-sudo",
-    "block-rm-rf",
-    "block-force-push",
-    "block-push-master",
-    "block-env-files",
-    "sanitize-api-keys",
-    "sanitize-jwt"
-  ],
-  "policyParams": {
-    "block-push-master": {
-      "protectedBranches": ["main", "release", "production"]
-    }
-  }
-}
-```
-
-Poi fai il commit:
-
-```bash
-git add .failproofai/policies-config.json
-git commit -m "Aggiungi politiche failproofai del team"
-```
-
-Ogni membro del team che ha failproofai installato raccoglierà automaticamente queste regole.
-
----
-
-## Costruisci uno standard di qualità a livello di organizzazione con politiche di convenzione
-
-La configurazione più impattante: commit `.failproofai/policies/` nel tuo repository con politiche personalizzate per il tuo progetto. Ogni membro del team le ottiene automaticamente — nessun comando di installazione, nessun cambiamento di configurazione.
-
-<Steps>
-  <Step title="Crea la directory e aggiungi le politiche">
-    ```bash
-    mkdir -p .failproofai/policies
-    ```
-
-    ```js
-    // .failproofai/policies/team-policies.mjs
-    import { customPolicies, allow, deny, instruct } from "failproofai";
-
-    // Applica il package manager preferito del tuo team
-    // (o abilita invece la politica integrata prefer-package-manager)
-    customPolicies.add({
-      name: "enforce-bun",
-      match: { events: ["PreToolUse"] },
-      fn: async (ctx) => {
-        if (ctx.toolName !== "Bash") return allow();
-        const cmd = String(ctx.toolInput?.command ?? "");
-        if (/\bnpm\b/.test(cmd)) return deny("Usa bun invece di npm.");
-        return allow();
-      },
-    });
-
-    // Ricorda all'agent di eseguire i test prima di fare commit
-    customPolicies.add({
-      name: "test-before-commit",
-      match: { events: ["PreToolUse"] },
-      fn: async (ctx) => {
-        if (ctx.toolName !== "Bash") return allow();
-        if (/git\s+commit/.test(ctx.toolInput?.command ?? "")) {
-          return instruct("Esegui i test prima di fare commit.");
-        }
-        return allow();
-      },
-    });
-    ```
-  </Step>
-  <Step title="Commit su git">
-    ```bash
-    git add .failproofai/policies/
-    git commit -m "Aggiungi politiche di qualità del team"
-    ```
-  </Step>
-  <Step title="Continua a migliorare">
-    Mentre il tuo team incontra nuove modalità di fallimento, aggiungi politiche e fai push. Tutti ricevono l'aggiornamento al loro prossimo `git pull`. Queste politiche diventano uno standard di qualità vivo che cresce con il tuo team.
-  </Step>
-</Steps>
-
----
-
-## Altri esempi
-
-La directory [`examples/`](https://github.com/exospherehost/failproofai/tree/main/examples) nel repository contiene:
-
-| File | Cosa mostra |
-|------|---------------|
-| `policies-basic.js` | Politiche di avvio - blocca le scritture di produzione, force-push, script in pipe |
-| `policies-notification.js` | Avvisi Slack per notifiche di inattività e fine della sessione |
-| `policies-advanced/index.js` | Import transitivi, hook asincroni, scrubbing dell'output PostToolUse, gestione dell'evento Stop |

package/.next/standalone/docs/it/for-agents.mdx

@@ -1,38 +0,0 @@
----
-title: "Per gli agenti"
-description: "Aggiungi la conoscenza di Failproof AI al tuo agente di codifica in un comando. Funziona con Claude Code, Cursor, Windsurf e altri."
----
-
-Aggiungi il riferimento completo di Failproof AI al tuo agente di codifica in un comando. Funziona con Claude Code, Cursor, Windsurf e qualsiasi altro agente che supporti le skill.
-
-```bash
-npx skills add https://docs.befailproof.ai
-```
-
-`npx skills` rileva quali agenti hai installato e aggiunge la skill nel formato corretto per ognuno automaticamente.
-
-## Cosa copre la skill
-
-| Area | Cosa include |
-|------|---|
-| Policies | Nomi delle policy built-in, tipi di evento, parametri, abilita/disabilita |
-| Custom policies | `customPolicies.add()`, match filter, API `allow`/`deny`/`instruct` |
-| Context object | `ctx.eventType`, `ctx.toolName`, `ctx.toolInput`, `ctx.session` |
-| Configuration | Struttura di `policies-config.json`, scope merging, `policyParams` |
-| CLI | `failproofai policies --install`, `--uninstall`, `--custom`, scope |
-| Dashboard | Session viewer, policy activity, variabili di ambiente |
-| Architecture | Hook handler flow, exit code, contratto stdin/stdout |
-
-## La skill è completa?
-
-Mintlify genera `llms.txt` da tutte le pagine nella navigazione. La documentazione di Failproof AI copre l'API completa - ogni policy, opzione ed esempio è incluso. Se trovi qualcosa di mancante, la fonte è disponibile a `https://docs.befailproof.ai/llms-full.txt`.
-
-Per un contesto più mirato, collega direttamente a una pagina specifica:
-
-```bash
-# Solo l'API delle custom policies
-npx skills add https://docs.befailproof.ai/custom-policies
-
-# Solo le built-in policies
-npx skills add https://docs.befailproof.ai/built-in-policies
-```

package/.next/standalone/docs/it/getting-started.mdx

@@ -1,186 +0,0 @@
----
-title: Iniziare
-description: "Installa failproofai, abilita le policy e lascia che i tuoi agenti funzionino in modo affidabile"
-icon: rocket
----
-
-## Requisiti
-
-- **Node.js** >= 20.9.0
-- **Bun** >= 1.3.0 (opzionale - necessario solo per compilare dal codice sorgente)
-
----
-
-## Installazione
-
-<CodeGroup>
-
-```bash npm
-npm install -g failproofai
-```
-
-```bash bun
-bun add -g failproofai
-```
-
-</CodeGroup>
-
----
-
-## Avvio rapido
-
-<Steps>
-  <Step title="Abilita le policy">
-    Le policy sono regole che vengono eseguite prima e dopo ogni chiamata a uno strumento dell'agente. Catturano i comandi distruttivi, le perdite di segreti e altre modalità di guasto prima che causino danni.
-
-    ```bash
-    failproofai policies --install
-    ```
-
-    Questo scrive le entry di hook nel file `settings.json` di Claude Code. Puoi anche installare per un singolo progetto o selezionare policy specifiche:
-
-    ```bash
-    failproofai policies --install --scope project
-    failproofai policies --install block-sudo block-rm-rf sanitize-api-keys
-    ```
-  </Step>
-  <Step title="Verifica">
-    ```bash
-    failproofai policies
-    ```
-
-    Mostra ogni policy, se è abilitata e i parametri configurati.
-  </Step>
-  <Step title="Avvia la dashboard">
-    ```bash
-    failproofai
-    ```
-
-    Apre una dashboard locale su `http://localhost:8020` dove puoi sfogliare le sessioni, ispezionare le chiamate agli strumenti e gestire le policy.
-  </Step>
-  <Step title="Esegui il tuo agente">
-    Avvia Claude Code come al solito. Se l'agente tenta qualcosa di rischioso, failproofai lo intercetta automaticamente. Lascialo in esecuzione senza supervisione e rivedi quello che è accaduto nella dashboard.
-  </Step>
-</Steps>
-
----
-
-## Come funzionano le policy
-
-Ogni volta che un agente esegue uno strumento, Claude Code chiama failproofai come sottoprocesso:
-
-```text
-Claude Code  →  failproofai --hook PreToolUse  →  legge JSON da stdin
-                                                 valuta le policy
-                                                 scrive la decisione in stdout
-```
-
-Ogni policy restituisce una di tre decisioni:
-
-- **allow** - l'agente procede normalmente
-- **deny** - l'azione è bloccata, all'agente viene spiegato il motivo
-- **instruct** - contesto aggiuntivo viene aggiunto al prompt dell'agente
-
-<Note>
-Le policy vengono eseguite nel tuo processo locale. Nulla viene inviato a un servizio remoto.
-</Note>
-
----
-
-## Configura policy di team con policy basate su convenzione
-
-Il modo più veloce per stabilire standard di qualità in tutto il team è la convenzione `.failproofai/policies/`. Inserisci i file di policy in questa directory e vengono caricati automaticamente — nessun flag, nessuna modifica della configurazione, nessun comando di installazione.
-
-<Steps>
-  <Step title="Crea la directory delle policy">
-    ```bash
-    mkdir -p .failproofai/policies
-    ```
-  </Step>
-  <Step title="Aggiungi file di policy">
-    Copia gli esempi iniziali o scrivi i tuoi:
-
-    ```bash
-    cp node_modules/failproofai/examples/convention-policies/*.mjs .failproofai/policies/
-    ```
-
-    Oppure creane uno nuovo:
-
-    ```js
-    // .failproofai/policies/team-policies.mjs
-    import { customPolicies, allow, deny, instruct } from "failproofai";
-
-    customPolicies.add({
-      name: "test-before-commit",
-      match: { events: ["PreToolUse"] },
-      fn: async (ctx) => {
-        if (ctx.toolName !== "Bash") return allow();
-        if (/git\s+commit/.test(ctx.toolInput?.command ?? "")) {
-          return instruct("Esegui i test prima di eseguire il commit.");
-        }
-        return allow();
-      },
-    });
-    ```
-  </Step>
-  <Step title="Esegui il commit su git">
-    ```bash
-    git add .failproofai/policies/
-    git commit -m "Add team quality policies"
-    ```
-
-    Ogni membro del team che ha failproofai installato raccoglie automaticamente queste policy. Non è necessaria alcuna configurazione per sviluppatore.
-  </Step>
-</Steps>
-
-<Tip>
-Esegui il commit di `.failproofai/policies/` nel tuo repository in modo che l'intero team condivida gli stessi standard. Man mano che il tuo team scopre nuove modalità di guasto, aggiungi policy e esegui il push — tutti ricevono l'aggiornamento al prossimo `git pull`. Nel tempo queste policy diventano uno standard di qualità vivo che continua a migliorare.
-</Tip>
-
----
-
-## Archiviazione dei dati
-
-Tutta la configurazione e i log rimangono sul tuo computer:
-
-| Percorso | Cosa conserva |
-|------|----------------|
-| `~/.failproofai/policies-config.json` | Configurazione globale delle policy |
-| `~/.failproofai/hook-activity.jsonl` | Cronologia dell'esecuzione dei hook |
-| `~/.failproofai/hook.log` | Log di debug per gli errori dei hook personalizzati |
-| `.failproofai/policies-config.json` | Configurazione per progetto (sottoposta a commit) |
-| `.failproofai/policies-config.local.json` | Override personali (gitignored) |
-
----
-
-## Disinstallazione
-
-```bash
-failproofai policies --uninstall
-```
-
-Rimuove le entry di hook da `~/.claude/settings.json`. I file di configurazione in `~/.failproofai/` vengono mantenuti.
-
----
-
-## Passaggi successivi
-
-<CardGroup cols={2}>
-
-<Card title="Configurazione" icon="gear" href="/it/configuration">
-  Ambiti e formato del file di configurazione
-</Card>
-
-<Card title="Policy integrate" icon="shield" href="/it/built-in-policies">
-  Tutte le 26 policy con parametri
-</Card>
-
-<Card title="Policy personalizzate" icon="code" href="/it/custom-policies">
-  Scrivi le tue policy in JavaScript
-</Card>
-
-<Card title="Monitore agente" icon="chart-line" href="/it/dashboard">
-  Monitora le sessioni e rivedi l'attività delle policy
-</Card>
-
-</CardGroup>

package/.next/standalone/docs/it/introduction.mdx

@@ -1,57 +0,0 @@
----
-title: Failproof AI
-description: "Gestisci hook e policy che mantengono i tuoi agenti AI affidabili e in esecuzione autonoma"
----
-
-[![npm weekly downloads](https://img.shields.io/npm/dw/failproofai?style=flat-square&color=2ea44f)](https://www.npmjs.com/package/failproofai)
-
-Hook e policy che mantengono i tuoi agenti AI affidabili e in esecuzione autonoma - per **Claude Code** e **Agents SDK**.
-
-Gli agenti AI falliscono in modi prevedibili. Eseguono comandi distruttivi, perdono segreti, si allontanano dal compito assegnato, si bloccano in loop infiniti o spingono direttamente al ramo principale. Se lasciati incustoditi, i piccoli errori si moltiplicano a cascata.
-
-Failproof AI risolve questo problema con le **policy** - regole che si collegano ad ogni chiamata di strumento dell'agente e possono **rilevare i fallimenti**, **attenuarli** (bloccare, istruire, sanitizzare) e **avvisarti** quando qualcosa richiede attenzione. Una dashboard locale ti permette di controllare tutto in seguito.
-
-Tutto viene eseguito localmente. Nessun dato lascia la tua macchina.
-
-## Inizia
-
-<CardGroup cols={2}>
-
-<Card title="26 policy predefinite" icon="shield" href="/it/built-in-policies">
-  Blocca comandi distruttivi, previeni la perdita di segreti, mantieni gli agenti all'interno dei confini del progetto, e molto altro - pronto all'uso.
-</Card>
-
-<Card title="Policy personalizzate" icon="code" href="/it/custom-policies">
-  Scrivi le tue regole in JavaScript con una semplice API allow / deny / instruct.
-</Card>
-
-<Card title="Monitor agente" icon="chart-line" href="/it/dashboard">
-  Vedi cosa hanno fatto i tuoi agenti mentre eri via. Sfoglia le sessioni, ispeziona le chiamate ai tool, esamina dove le policy sono state applicate.
-</Card>
-
-<Card title="Configurazione semplice" icon="gear" href="/it/configuration">
-  Regola qualsiasi policy senza scrivere codice. Imposta liste consentite, rami protetti o soglie per progetto o globalmente.
-</Card>
-
-</CardGroup>
-
-## Avvio rapido
-
-<CodeGroup>
-
-```bash npm
-npm install -g failproofai
-```
-
-```bash bun
-bun add -g failproofai
-```
-
-</CodeGroup>
-
-```bash
-failproofai policies --install   # abilita le policy
-failproofai                      # avvia la dashboard
-```
-
-Consulta la guida [Inizia](/it/getting-started) per la procedura dettagliata completa.

package/.next/standalone/docs/it/package-aliases.mdx

@@ -1,82 +0,0 @@
----
-title: Alias dei Pacchetti
-description: "Alias registrati per la prevenzione del typosquatting e come funzionano"
-icon: copy
----
-
-## Pacchetto ufficiale
-
-Il pacchetto npm canonico è **`failproofai`**:
-
-```bash
-npm install -g failproofai
-# or
-bun add -g failproofai
-```
-
----
-
-## Perché possediamo i nomi degli alias
-
-Il typosquatting è un attacco comune alla supply chain in cui un malintenzionato registra un nome di pacchetto che è a una pressione di tasto di distanza da un pacchetto popolare. Gli utenti ignari che digitano male il comando di installazione finiscono per eseguire codice controllato dall'attaccante con accesso completo al sistema - esattamente il tipo di minaccia che Failproof AI è progettato per difendere.
-
-Per eliminare questa superficie di attacco, **possediamo preventivamente tutte le comuni varianti di ortografia e formattazione** di `failproofai` su npm. Nessuno di questi nomi può essere registrato da terzi. Ognuno di essi è un proxy sottile che installa e delega al vero pacchetto `failproofai`.
-
----
-
-## Alias registrati
-
-**Varianti di formattazione** - diversi modi di scrivere "failproof ai":
-
-| Pacchetto | Stato |
-|---------|--------|
-| `failproof` | ✅ Pubblicato |
-| `failproof-ai` | ⏳ In attesa di supporto npm |
-| `fail-proof-ai` | ⏳ In attesa di supporto npm |
-| `failproof_ai` | ⏳ In attesa di supporto npm |
-| `fail_proof_ai` | ⏳ In attesa di supporto npm |
-| `fail-proofai` | ⏳ In attesa di supporto npm |
-
-**Errori di digitazione `failprof*`** - manca una `o` da "proof":
-
-| Pacchetto | Stato |
-|---------|--------|
-| `failprof` | ✅ Pubblicato |
-| `failprof-ai` | ✅ Pubblicato |
-| `failprofai` | ⏳ In attesa di supporto npm |
-| `fail-prof-ai` | ⏳ In attesa di supporto npm |
-| `failprof_ai` | ⏳ In attesa di supporto npm |
-
-**Errori di digitazione `faliproof*`** - `a` e `i` invertite:
-
-| Pacchetto | Stato |
-|---------|--------|
-| `faliproof` | ✅ Pubblicato |
-| `faliproof-ai` | ✅ Pubblicato |
-| `faliproofai` | ⏳ In attesa di supporto npm |
-
-> **Perché in sospeso?** La politica anti-spam di npm blocca i nomi che si normalizzano alla stessa stringa di un pacchetto esistente dopo aver rimosso la punteggiatura e eseguito controlli di somiglianza. Abbiamo contattato il supporto npm per riservare questi nomi a scopo di prevenzione del typosquatting. Saranno attivati una volta approvati.
-
-Puoi verificare che qualsiasi alias pubblicato sia di nostra proprietà:
-
-```bash
-npm info failproof
-# Cercare: "ExosphereHost Inc." nel campo maintainers
-```
-
----
-
-## Come funzionano gli alias
-
-Ogni pacchetto alias:
-
-1. Elenca `failproofai` come dipendenza - in modo che il vero pacchetto (inclusa la configurazione del suo hook `postinstall`) venga eseguito all'installazione
-2. Espone un binario che corrisponde al suo nome (ad es. `failprof-ai`) che inoltra tutti gli argomenti al binario `failproofai`
-
-Il proxy è uno script Node a due righe; non c'è logica, nessuna chiamata di rete e nessuna raccolta dati oltre a quella che fa `failproofai` stesso.
-
----
-
-## Se trovi un nome che ci è sfuggito
-
-Apri un issue su [exospherehost/failproofai](https://github.com/exospherehost/failproofai/issues) e lo registreremo.