Antivirus open-source per agenti AI: blocca strumenti rischiosi, accesso ai segreti, prompt injection, pacchetti malevoli, server MCP, plugin e skill a runtime.
 | Ferma le azioni AI rischiose prima che compromettano la tua macchina. HOL Guard è un livello di sicurezza local-first per agenti AI, strumenti, plugin, skill, server MCP e installazioni di pacchetti. Installa HOL Guard Leggi la documentazione Pacchetto PyPI ( hol-guard)Segnala un problema |
|---|
HOL Guard esamina le azioni degli agenti prima che vengano eseguite: comandi shell, accesso ai file, installazioni di pacchetti e chiamate agli strumenti MCP. Rileva l'esposizione di segreti, operazioni distruttive, prompt injection e rischi della supply chain, quindi consente, blocca o richiede approvazione in base alla tua policy.
Eseguilo localmente senza un account. Usa la CLI e la dashboard locale per gestire la protezione, risolvere le approvazioni e ispezionare la cronologia delle decisioni. Guard Cloud opzionale aggiunge cronologia condivisa, policy di team e gestione della flotta.
Per iniziare · Agenti supportati · Scanner di plugin · Documentazione · Contribuisci con un'estensione · Sviluppo
Richiede Python 3.10 o superiore e pipx.```bash pipx install hol-guard hol-guard init
Il wizard di primo avvio rileva gli agenti supportati e ti guida attraverso la configurazione della protezione. Chiede conferma prima di ogni modifica alla configurazione, inclusa l'apertura della dashboard, l'installazione delle integrazioni degli agenti e la connessione di servizi cloud opzionali.
Verifica la tua installazione:```bash
hol-guard --version
hol-guard status
Per aggiornare un'installazione esistente:```bash hol-guard update
Per la configurazione manuale, consulta la [guida all'installazione](https://github.com/hashgraph-online/hol-guard/blob/main/docs/guard/get-started.md). I dettagli sulle release e le prerelease sono disponibili nella [pagina delle release](https://github.com/hashgraph-online/hol-guard/releases).
## Cosa protegge HOL Guard
| Superficie | Protezione |
| :--- | :--- |
| **Comandi shell e accesso ai file** | Esamina operazioni distruttive, accesso a file sensibili, esposizione di credenziali e comandi in uscita sospetti. |
| **Installazioni di pacchetti** | Valuta le operazioni supportate dei gestori di pacchetti rispetto alle informazioni sulla supply chain prima dell'installazione. |
| **Plugin, skill e configurazione degli agenti** | Cataloga gli artefatti locali ed esamina strumenti nuovi o modificati prima dell'avvio. |
| **Server e strumenti MCP** | Ispeziona la configurazione dei server ed esamina le chiamate agli strumenti tramite hook supportati e proxy gestiti. |
| **Prompt e risultati degli strumenti** | Analizza gli eventi supportati per il prompt injection e i contenuti sensibili. |
| **Approvazioni e prove** | Instrada le decisioni verso i prompt nativi o il centro di approvazione e registra ricevute locali per la revisione. |
Guard si connette tramite hook nativi degli agenti, proxy MCP gestiti e integrazioni di avvio. La copertura dipende dagli eventi che ciascun agente espone; la [matrice di supporto](https://github.com/hashgraph-online/hol-guard/blob/main/docs/guard/harness-support.md) documenta l'applicazione, la consegna delle approvazioni e il comportamento in caso di errore per ogni integrazione.
## Agenti AI supportati
Codex, Claude Code, GitHub Copilot CLI, Cursor, Cline, Gemini CLI, Grok, Hermes, Kimi Code, Pi, oh-my-pi, OpenClaw, OpenCode, Antigravity e ZCode. [Paseo](https://github.com/hashgraph-online/hol-guard/blob/main/docs/guard/paseo.md) è supportato tramite queste integrazioni native dei provider, con copertura per ciascun provider.
Ad esempio, per configurare Codex in modo esplicito:```bash
hol-guard install codex
hol-guard run codex --dry-run
hol-guard run codex
La dry run registra lo stato corrente degli artefatti prima del lancio. Per Codex, Guard installa hook nativi pre-tool e rifiuta un lancio gestito se tali hook sono mancanti o disabilitati.
| Attività | Comando |
|---|---|
| Verifica lo stato della protezione | hol-guard status |
| Diagnostica un'integrazione con un agente | hol-guard doctor codex |
| Ispeziona le modifiche prima del lancio | hol-guard diff codex |
| Rivedi le approvazioni in sospeso | hol-guard approvals |
| Approva o nega una richiesta | hol-guard approvals approve <request-id> / hol-guard approvals deny <request-id> |
| Leggi la cronologia delle decisioni | hol-guard receipts |
| Elenca gli artefatti tracciati | hol-guard inventory |
| Esporta una distinta base AI | hol-guard abom --format json |
| Scansiona le dipendenze del workspace | hol-guard supply-chain scan |
| Connetti la sincronizzazione cloud opzionale | hol-guard connect |
Ispeziona la classificazione del comando e le regole corrispondenti:```bash hol-guard command test 'rm -rf ./build' hol-guard command explain 'git clean -ndx' hol-guard command extensions command.git --json
`command test` e `command explain` ispezionano il comando senza eseguirlo né creare un'approvazione. Usa `hol-guard approvals` per risolvere una richiesta in sospeso e `hol-guard receipts` per rivedere la decisione registrata.
La [directory delle estensioni](https://github.com/hashgraph-online/hol-guard/blob/main/docs/guard/extensions/README.md) elenca la copertura dei comandi generata dal registro di runtime. I contributi esterni richiedono un opt-in esplicito; le protezioni core obbligatorie rimangono abilitate. Per aggiungere copertura, segui la [guida ai contributi per le estensioni](https://github.com/hashgraph-online/hol-guard/blob/main/docs/guard/extensions/contributing.md).
### Verificare un pacchetto```bash
hol-guard supply-chain sync
hol-guard supply-chain scan
hol-guard supply-chain explain [email protected] --ecosystem npm
Il verdetto del pacchetto include le prove di advisory disponibili e la copertura dell'ecosistema. Consulta la guida introduttiva per l'intercettazione del package manager e la guida alla remediation per la gestione dei falsi positivi.
Questo repository include anche plugin-scanner, una CLI per i maintainer che desiderano controlli di sicurezza e qualità prima di pubblicare plugin per agenti, skill e integrazioni MCP.```bash
pipx install plugin-scanner
plugin-scanner scan .
plugin-scanner lint .
plugin-scanner verify .
| Comando | Scopo |
| :--- | :--- |
| `scan` | Risultati di sicurezza e un report di qualità su tutte le superfici dei pacchetti rilevate. |
| `lint` | Feedback di authoring a livello di regola. |
| `verify` | Controlli di prontezza per la superficie di installazione e il runtime. |
| `submit` | Un artefatto di submission per un pacchetto plugin. |
| `doctor` | Diagnostica dei componenti e bundle di troubleshooting. |
Lo scanner rileva i formati di pacchetto Codex, Claude Code, DeepSeek Harness, Gemini CLI, Kimi Code e OpenCode. Usa `plugin-scanner --list-ecosystems` per elencarli o `--ecosystem` per selezionarne uno. Alla radice di un marketplace Codex, rileva automaticamente le voci dei plugin locali.
I controlli coprono manifest, segreti, configurazione del trasporto e dei comandi MCP, impostazioni predefinite di approvazione, skill, lockfile delle dipendenze e permessi di GitHub Actions. Le integrazioni opzionali Cisco aggiungono l'analisi di skill e MCP. I report supportano testo, JSON, Markdown e SARIF.```bash
plugin-scanner scan . --format sarif --output plugin-scanner.sarif
plugin-scanner scan . --fail-on-severity high
I gradi di qualità utilizzano i controlli applicabili a ciascun pacchetto. Il punteggio di affidabilità ha provenienza e pesi separati; consulta i riferimenti di scoring per skill, MCP e plugin.
Aggiungi lo scanner a un repository di plugin:```yaml name: Plugin security on: [push, pull_request]
permissions: contents: read
jobs: scan: runs-on: ubuntu-latest steps: - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6 - uses: hashgraph-online/ai-plugin-scanner-action@fdb49f9d85321a2ced2933301b395dd3c1ce9c8f # v1.2.631 with: plugin_dir: "." min_score: 80 fail_on_severity: high
Consulta la [documentazione dell'azione](https://github.com/hashgraph-online/ai-plugin-scanner-action) per i caricamenti SARIF, i flussi di lavoro di invio e gli output leggibili dalla macchina. Il codice sorgente dell'azione è mantenuto in [`action/`](https://github.com/hashgraph-online/hol-guard/blob/main/action).
<a id="install-the-package-you-need"></a>
<a id="resolver-safe-cisco-extra"></a>
### Analisi Cisco opzionale
I pacchetti di base funzionano senza le dipendenze Cisco. Per aggiungere la scansione delle competenze Cisco, usa Python dalla 3.11 alla 3.14 e installa l'extra in un ambiente isolato:```bash
pipx install 'plugin-scanner[cisco]'
Per l'analisi di Cisco MCP, utilizzare l'immagine Docker del repository o il gruppo di dipendenze cisco-mcp:```bash
uv sync --extra dev --extra cisco --group cisco-mcp --python 3.13
uv run plugin-scanner scan . --cisco-skill-scan on --cisco-mcp-scan on
L'extra `cisco` pubblicato fornisce la scansione delle skill; il gruppo separato `cisco-mcp` fornisce lo scanner MCP. Le versioni delle dipendenze e i vincoli Python sono mantenuti in [`pyproject.toml`](https://github.com/hashgraph-online/hol-guard/blob/main/pyproject.toml).
## Supporto Ecosistemi
| Ecosistema | Superfici di rilevamento |
| :--- | :--- |
| Codex | `.codex-plugin/plugin.json`, `marketplace.json`, `.agents/plugins/marketplace.json` |
| Claude Code | `.claude-plugin/plugin.json`, `.claude-plugin/marketplace.json` |
| DeepSeek Harness | `package.json` con `dsh.bundle`, patch dichiarate ed esportazioni `apply(ctx)` di Cordis, oppure `dsh.bundle.mode` impostato a `"patch"` per bundle di sole patch |
| Gemini CLI | `gemini-extension.json`, `commands/**/*.toml` |
| Kimi Code | `kimi.plugin.json`, `.kimi-plugin/plugin.json`, skill, agenti, comandi, prompt e server MCP dichiarati |
| OpenCode | `opencode.json`, `opencode.jsonc`, `.opencode/commands`, `.opencode/plugins` |
Usa `--ecosystem auto` per rilevare i pacchetti supportati in un repository, oppure seleziona esplicitamente un ecosistema:```bash
plugin-scanner scan ./plugins-repo --ecosystem claude
plugin-scanner scan ./dsh-plugin --ecosystem deepseek-harness
| Categoria | Copertura |
|---|---|
| Validazione del manifest | Campi obbligatori, versioni, percorsi dichiarati, metadati dell'interfaccia, link e asset. |
| Sicurezza | Segreti hardcoded, comandi e trasporti MCP non sicuri e impostazioni di approvazione predefinite rischiose. |
| Sicurezza operativa | Permessi di GitHub Actions e dipendenze bloccate, pattern di checkout privilegiati, Dependabot e lockfile. |
| Pacchettizzazione dei plugin | File README e licenza, frontmatter delle skill, regole di ignore e file di ambiente committati accidentalmente. |
| Marketplace | Validità del manifest, scoperta dei pacchetti locali e percorsi sorgente sicuri. |
| Analisi di skill e MCP | Disponibilità dell'analizzatore, risultati e analizzabilità dalle integrazioni opzionali di Cisco. |
| Qualità del codice | Esecuzione dinamica di codice e pattern di shell injection. |
Plugin Scanner riporta un grado di qualità insieme alla provenienza dell'affidabilità. I punteggi di qualità sono normalizzati su tutti i controlli applicabili, così le superfici opzionali non gonfiano il grado di un pacchetto.
L'affidabilità delle skill utilizza gli ID degli adapter di base HCS-28, i pesi e le regole del denominatore. L'affidabilità dei plugin MCP e Codex utilizza adapter espliciti, pesi e modalità di contribuzione documentati nelle specifiche locali:
plugin-scanner scan ./my-plugin --format json --profile public-marketplace
plugin-scanner lint ./my-plugin --list-rules plugin-scanner lint ./my-plugin --explain README_MISSING
plugin-scanner lint ./my-plugin --fix --profile strict-security
plugin-scanner verify ./my-plugin --format json plugin-scanner verify ./my-plugin --online --format text
plugin-scanner submit ./my-plugin --profile public-marketplace --attest dist/plugin-quality.json
plugin-scanner doctor ./my-plugin --component mcp --bundle dist/doctor.zip
Per un marketplace di repository, `scan`, `lint`, `verify` e `doctor` possono avere come target la root. `submit` ha come target un singolo pacchetto plugin.
## Allineamento alla specifica Codex
Lo scanner riconosce i manifest dei plugin Codex, i metadati dell'interfaccia, gli asset dichiarati e i pacchetti del marketplace:
- I percorsi dei manifest locali usano il prefisso `./`; `lint --fix` li preserva o li aggiunge.
- `.agents/plugins/marketplace.json` è la posizione preferita per il marketplace, con il supporto di `marketplace.json` nella root per compatibilità.
- La validazione dell'interfaccia controlla i link e gli asset dichiarati senza richiedere un campo `type` non documentato.
- `verify --online` controlla la raggiungibilità HTTP remota. L'esecuzione del server Stdio viene saltata per la revisione manuale.
Consulta la [documentazione dei plugin Codex](https://developers.openai.com/codex/plugins) e la [specifica Model Context Protocol](https://modelcontextprotocol.io) per i formati upstream.
## Esempio di configurazione + baseline
Configura lo scanner in `.plugin-scanner.toml`:```toml
[scanner]
profile = "public-marketplace"
baseline_file = "baseline.txt"
ignore_paths = ["tests/*", "fixtures/*"]
[rules]
disabled = ["README_MISSING"]
severity_overrides = { CODEXIGNORE_MISSING = "low" }
L'azione GitHub richiede trust_repository_policy: true prima che la configurazione e le baseline di proprietà del repository possano modificarne il verdetto. Abilitare questa opzione solo per le policy di cui si intende che il workflow si fidi.
| Formato | Utilizzo |
|---|---|
text | Riepiloghi da terminale con totali per categoria e risultati. |
json | Report strutturati per script e integrazioni. |
markdown | Report pronti per la revisione di pull request e issue. |
sarif | Scansione del codice GitHub e automazione della sicurezza. |
La AI Plugin Scanner Action supporta gate di sicurezza, upload SARIF, acquisizione delle submission e payload del registry. Il suo codice sorgente risiede in action/, e il workflow di pubblicazione distribuisce il bundle dell'azione.
La legacy HOL Codex Plugin Scanner Action rimane disponibile per i workflow esistenti.
Usare submission_enabled: true per aprire o riutilizzare una issue di submission quando un plugin raggiunge la soglia configurata. submission_token deve avere il permesso di creare issue nel repository di submission di destinazione. L'azione emette lo stato della submission e gli URL delle issue come output.
Consultare il riferimento degli input dell'azione per submission_score_threshold, submission_token e le opzioni del repository di destinazione.
Impostare registry_payload_output per scrivere un payload leggibile da macchina per un registry o una pipeline di badge. L'azione espone anche gli output score, grade, grade_label, max_severity e findings_total e può scrivere un riepilogo del job.
Il plugin HOL Registry Broker è un esempio di plugin agente nel HOL Plugin Registry. La sua scheda nel registry fornisce le informazioni di trust attuali.
Gli agenti AI possono eseguire comandi, installare dipendenze, leggere file e chiamare strumenti esterni all'interno di una singola sessione. HOL Guard esamina queste azioni nei punti di esecuzione supportati e mantiene insieme la decisione di policy, la richiesta di approvazione e la ricevuta.
Usalo per la sicurezza degli agenti AI su una macchina di sviluppo, la sicurezza MCP attorno agli strumenti connessi e i controlli della supply chain per pacchetti e plugin. I team possono aggiungere Guard Cloud per approvazioni condivise e gestione delle policy mantenendo la protezione locale.
HOL Guard è un antivirus open-source e una protezione runtime per agenti AI. Esamina le chiamate agli strumenti supportate, i comandi shell, l'accesso ai file e le operazioni sui pacchetti per rischi come l'esposizione di segreti, il prompt injection, le azioni distruttive e le dipendenze malevole.
Sì. La protezione locale, i comandi CLI, le approvazioni e le ricevute funzionano senza effettuare l'accesso. Guard Cloud è opzionale e aggiunge evidenze sincronizzate, controlli di team e visibilità sulla flotta. Consultare Local Guard vs. Guard Cloud per il confine delle funzionalità.
Guard include adapter per Codex, Claude Code, GitHub Copilot CLI, Cursor, Cline, Gemini CLI, Grok, Hermes, Kimi Code, Pi, oh-my-pi, OpenClaw, OpenCode, Antigravity e ZCode. Paseo è supportato attraverso queste integrazioni native dei provider, con copertura per provider. La matrice di supporto spiega quali eventi e percorsi di enforcement supporta ciascun adapter.
Installare hol-guard per proteggere l'attività degli agenti sulla propria macchina. Installare plugin-scanner per ispezionare i pacchetti dei plugin e applicare controlli di sicurezza e qualità in CI. Questo repository compila e pubblica entrambe le distribuzioni.
Guard ispeziona la configurazione dei server MCP ed esamina le chiamate agli strumenti MCP supportate attraverso gli hook degli agenti e i proxy gestiti. Plugin Scanner controlla la configurazione MCP e la raggiungibilità remota HTTP; l'analisi opzionale Cisco MCP aggiunge risultati di sicurezza statici.
L'azione potrebbe richiedere approvazione in base alla policy attiva, oppure i suoi strumenti o artefatti potrebbero essere cambiati. Iniziare con hol-guard approvals, ispezionare il comando con hol-guard command explain '<command>' e usare hol-guard receipts per rivedere la decisione registrata.
| Guida | Contenuti |
|---|---|
| Get started | Installazione, configurazione manuale, protezione dei pacchetti e comandi comuni. |
| Agent support | Copertura delle integrazioni e comportamento delle approvazioni. |
| Architecture | Componenti runtime e flusso decisionale. |
| Policy specification | Formato del documento GuardPolicy. |
| Policy recipes | Esempi di configurazione per workflow comuni. |
| Extensions | Regole di comando integrate e guida ai contributi. |
| Contribute an extension | Generare, revisionare, integrare e testare una nuova estensione con la CLI. |
| Local vs. cloud | Funzionalità locali e servizi cloud opzionali. |
| Troubleshooting | Diagnosi e ripristino. |
| Security | Segnalazione di vulnerabilità e policy di divulgazione. |
Usare la Extension Builder CLI per trasformare metadati di comandi esportati o un inventario di strumenti MCP in file di contributo e test. Funziona offline: legge l'export senza importare o eseguire lo strumento di destinazione.
1. Proporre la copertura. Controllare la Directory delle estensioni per la copertura esistente. Per una nuova funzionalità, aprire una Proposta di estensione con l'ID command.<name> proposto, le operazioni supportate, esempi distruttivi, controparti sicure e riferimenti upstream. Estendere un'estensione esistente quando già possiede l'operazione.
Seguire la configurazione di sviluppo, poi eseguire gli esempi seguenti dal proprio checkout di HOL Guard. uv run --no-sync usa la versione di sviluppo installata di quel checkout.
2. Generare un kit di contributo. Questo esempio usa l'inventario sintetico samplectl incluso nel repository. Per il proprio contributo, sostituire l'input e i metadati con l'export del proprio strumento e i dettagli pubblici del publisher.```bash
uv run --no-sync hol-guard extensions generate --from cli
--input docs/guard/extension-builder/examples/cli-surface.json
--slug samplectl --executable samplectl --name 'Sample CLI'
--publisher community.example --publisher-name 'Example Maintainer'
--homepage https://example.test/samplectl
--upstream-version 1.0.0 --output samplectl-kit
uv run --no-sync hol-guard extensions validate samplectl-kit
La directory di output deve essere nuova, con una directory padre esistente. Il kit include `discovery.json`, `review.json`, `report.json`, metadati di contribuzione, un detector nativo, test generati e un manifest dei file.
Altri input: `--from help` legge l'help dei comandi salvato; `--from click` legge un export `Context.to_info_dict()` di Click; `--from oclif` legge `oclif.manifest.json`; `--from mcp` legge un risultato `tools/list` esportato completo; e `--from snapshot` riproduce `discovery.json`. L'esempio `cli` sopra utilizza il JSON normalizzato `guard.cli-surface.v1`.
Per le contribuzioni MCP, il generatore utilizza `--launcher` e `--package` invece di `--executable`. Consulta l'[esempio del kit MCP](https://github.com/hashgraph-online/hol-guard/blob/main/docs/guard/extension-builder/README.md#generate-an-mcp-kit) per un comando completo e i requisiti di paginazione.
**3. Rivedi le operazioni e rigenera.** Leggi `report.json` e confronta le operazioni scoperte con l'implementazione upstream. Copia il file di revisione prima di modificarlo:```bash
cp samplectl-kit/review.json samplectl-review.json
Modifica samplectl-review.json, mantenendo intatti il suo binding di discovery e gli ID delle operazioni. Le operazioni CLI usano review o block; l'operazione root rimane review. Imposta reviewed: true per le voci che hai valutato, con motivazione e un riferimento di evidenza HTTPS pubblico. Aggiungi safeArgv solo per invocazioni esatte e verificate come sicure. Il formato di review include un esempio completo di voce.
Ricompila dallo snapshot salvato invece di modificare i detector o i manifest generati:```bash
uv run --no-sync hol-guard extensions generate --from snapshot
--input samplectl-kit/discovery.json
--review samplectl-review.json --output samplectl-reviewed
uv run --no-sync hol-guard extensions validate samplectl-reviewed uv run --no-sync hol-guard extensions diff samplectl-kit samplectl-reviewed
`diff` restituisce `0` per kit uguali e `1` quando kit validi differiscono. Se l'export upstream cambia, genera e revisiona un nuovo snapshot.
**4. Anteprima e applicazione dell'integrazione.** Sul tuo branch di contribuzione, visualizza in anteprima le modifiche al checkout corrente:```bash
uv run --no-sync hol-guard extensions apply samplectl-reviewed --repo .
Ispeziona i percorsi elencati e i file generati. Copia il digest del piano stampato nel seguente comando prima di eseguirlo:```bash
uv run --no-sync hol-guard extensions apply samplectl-reviewed --repo .
--expected-plan THE_PRINTED_PLAN_DIGEST
--write
L'operazione di scrittura applica il piano revisionato ai file di contribuzione, alla mappa di fiducia esterna, alla registrazione nel catalogo, al packaging e ai record di proprietà dell'autore. ID esistenti o file in conflitto interrompono l'integrazione per la revisione.
**5. Testare e inviare una pull request.** Per l'esempio `samplectl`:```bash
uv run --no-sync python scripts/release/stage_guard_cloud_review_artifacts.py
uv run --no-sync pytest -q tests/test_generated_cli_samplectl_extension.py
uv run --no-sync pytest -q \
tests/test_guard_extension_contribution.py \
tests/test_guard_extension_trust.py \
tests/test_guard_command_extension_registry.py
uv run --no-sync python scripts/render_command_extension_directory.py
uv run --no-sync python scripts/render_command_extension_directory.py --check
git diff --check
Usa il nome file di test generato per uno slug diverso. Aggiungi casi per operazioni distruttive, anteprime sicure, alias, flag riordinati, quoting, input malformato e comandi composti. Esegui i controlli di lint e formattazione sui file Python modificati. Ispeziona il diff finale, esegui il commit dell'integrazione e della directory rigenerata, e apri una PR verso main collegando la proposta e i risultati dei test. Includi i record di authoring generati; tieni le directory scratch dei kit e gli export upstream grezzi fuori dalla PR.
I contributi della community rimangono External e disattivati per impostazione predefinita. I test devono dimostrare che sono inerti finché un amministratore locale non li abilita. Generare, applicare o unire un contributo non lo attiva, e il suo detector non può indebolire le protezioni richieste da Guard.
Riferimento completo del builder · Requisiti di revisione dei contributi · Contratto delle estensioni External · Validazione del builder
Clona il repository e installa le dipendenze di sviluppo con uv:```bash git clone https://github.com/hashgraph-online/hol-guard.git cd hol-guard uv sync --extra dev uv run ruff check src tests uv run ruff format --check src tests uv run pytest --tb=short uv build
Per la copertura opzionale di Cisco, usa il comando del gruppo di dipendenze sopra. Vedi [CONTRIBUTING.md](https://github.com/hashgraph-online/hol-guard/blob/main/CONTRIBUTING.md) per i requisiti di contribuzione e la [matrice di test](https://github.com/hashgraph-online/hol-guard/blob/main/docs/guard/testing-matrix.md) per i test di integrazione.
## Risorse
- [HOL Plugin Registry](https://hol.org/registry/plugins)
- [HOL Plugin Security dataset on Hugging Face](https://huggingface.co/datasets/HashgraphOnline/hol-plugin-security)
- [HOL Standards Documentation](https://hol.org/docs/standards)
- [OpenAI Codex Plugin Documentation](https://developers.openai.com/codex/plugins)
- [Model Context Protocol Documentation](https://modelcontextprotocol.io)
- [Cisco AI Skill Scanner](https://pypi.org/project/cisco-ai-skill-scanner/)
- [Cisco AI MCP Scanner](https://pypi.org/project/cisco-ai-mcp-scanner/)
- [HOL GitHub Organization](https://github.com/hashgraph-online)
## Community
Mantenuto da [Hashgraph Online](https://github.com/hashgraph-online).
- [Segnala un bug o richiedi una funzionalità](https://github.com/hashgraph-online/hol-guard/issues)
- [Sfoglia le release](https://github.com/hashgraph-online/hol-guard/releases)
- [Esplora il dataset sulla sicurezza dei plugin](https://huggingface.co/datasets/HashgraphOnline/hol-plugin-security)
## Licenza
Concesso in licenza sotto [Apache-2.0](https://github.com/hashgraph-online/hol-guard/blob/main/LICENSE).