diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..ed7fcaa
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,295 @@
+# 🤖 AGENTS.md
+
+```markdown
+# 🤖 AGENTS.md - Network Config Backup Plugin for GLPI 11
+
+> **Documento di contesto per AI Agent / Assistente di sviluppo**  
+> **Progetto**: `glpi-plugin-netconfig`  
+> **Ultimo aggiornamento**: 2026-05-22  
+> **GLPI Target**: 11.0.6+ | **PHP**: 8.2+ | **Database**: MySQL/MariaDB
+
+---
+
+## 🎯 Obiettivo del Progetto
+
+Sviluppare un plugin GLPI 11 che permetta di:
+1. **Salvare configurazioni** di apparati di rete (switch, router, firewall) nel database MySQL di GLPI
+2. **Tracciare le variazioni** delle configurazioni nel tempo (versioning con hash SHA256)
+3. **Visualizzare differenze** (diff) tra versioni successive
+4. **Esportare configurazioni** in file di testo (con controllo diritti e redaction credenziali)
+5. **Lanciare il recupero configurazioni** tramite massive actions o trigger manuali
+6. **Integrare GLPI Agent remoto** per l'esecuzione distribuita del backup via SSH (netmiko/napalm)
+
+---
+
+## 🧠 Contesto Tecnico Chiave
+
+### Stack Tecnologico
+| Componente | Versione/Nota |
+|------------|--------------|
+| GLPI | 11.0.6+ (CLI: `php bin/console glpi:version`) |
+| PHP | 8.2+ con strict_types, namespace PSR-4 |
+| Database | MySQL/MariaDB, InnoDB, utf8mb4_unicode_ci |
+| Composer | 2.7.1+ (cache Packagist OK) |
+| Template Engine | Twig 3 (nativo in GLPI 11) |
+| Crittografia | `Glpi\Toolbox\Encryption` (AES-256-GCM) |
+| Diff Engine | `symfony/diff` ^6.4 |
+| HTTP Client | `guzzlehttp/guzzle` ^7.8 (opzionale per agent PHP) |
+| Agent Script | Python 3 + netmiko + requests + pyyaml |
+
+### Architettura Plugin
+```
+plugins/netconfig/
+├── setup.php                     # Hook init, versioning, diritti
+├── hook.php                      # Install/uninstall DB
+├── composer.json                 # Dipendenze + autoload PSR-4
+├── install/mysql/install.sql     # Schema tabella configs
+├── src/
+│   ├── Config.php                # CommonDBTM: CRUD, massive actions, diff
+│   ├── Agent/Receive.php         # Endpoint API per agent
+│   └── Api/GlpiApiClient.php     # Client REST API GLPI (opzionale)
+├── ajax/
+│   ├── export.php                # Download sicuro configurazioni
+│   └── agent_receive.php         # Fallback endpoint agent
+├── templates/config_tab.html.twig # Vista tab GLPI con storico
+└── locales/                      # Traduzioni it_IT/en_GB
+```
+
+### Flusso Dati Principale
+```
+[Apparato di Rete] 
+       │
+       ▼ (SSH via netmiko)
+[GLPI Agent Python] ──(POST JSON)──► [Plugin Endpoint]
+                                          │
+                                          ▼
+                                   [Validazione Token + Hash]
+                                          │
+                                          ▼
+                                   [Cifratura + Salvataggio DB]
+                                          │
+                                          ▼
+                                   [Notifica UI GLPI + Diff]
+```
+
+---
+
+## 🔑 Decisioni Architetturali Critiche
+
+### ✅ Scelte Confermate
+1. **Namespace PSR-4**: `PluginNetconfig\` mappato su `src/` (obbligatorio GLPI 11)
+2. **Cifratura nativa**: Uso di `Glpi\Toolbox\Encryption` invece di soluzioni custom
+3. **Versioning via hash**: SHA256 su contenuto config per rilevamento modifiche
+4. **Massive actions native**: Integrazione con sistema GLPI invece di UI custom
+5. **Agent remoto Python**: Netmiko per compatibilità multi-vendor (Cisco, HP, Juniper, etc.)
+6. **Token-based auth**: `NETCONFIG_AGENT_TOKEN` per validazione richieste agent
+7. **Diff lato server**: `symfony/diff` con output HTML sanitizzato per Twig
+8. **Export con redaction**: Regex per mascherare password/secret prima del download
+
+### ⚠️ Alternative Valutate e Scartate
+| Alternativa | Motivo Scarto |
+|-------------|--------------|
+| Backup via SSH diretto da PHP (phpseclib) | Scaling problematico, timeout, gestione credenziali complessa |
+| Integrazione Oxidized/RANCID via webhook | Overhead infrastrutturale, duplicazione logica versioning |
+| Archiviazione config su filesystem invece di DB | Perdita integrazione con ACL/profile GLPI, backup/disaster recovery più complesso |
+| Agent in PHP invece di Python | Netmiko/napalm hanno supporto multi-vendor più maturo in Python |
+
+### 🔐 Security by Design
+- **Credenziali di rete**: Mai hardcodate. Usare variabili d'ambiente o vault esterno
+- **Token agente**: Generato con `openssl rand -hex 32`, rotazione periodica consigliata
+- **Cifratura a riposo**: `config_content` cifrato con chiave GLPI (`crypt_key` in config_db.php)
+- **Export sicuro**: Controllo `Session::haveRight()` + redaction automatica credenziali
+- **API endpoint**: Validazione CSRF per chiamate browser, token per chiamate agent
+- **Log sensibili**: Nessun dato di configurazione nei log di sistema
+
+---
+
+## 📡 Endpoint API del Plugin
+
+### POST `/plugins/netconfig/ajax/agent_receive.php`
+**Scopo**: Ricevere configurazioni da GLPI Agent remoto
+
+**Request JSON**:
+```json
+{
+  "device_id": 123,
+  "config": "!\nhostname SW-TEST\n...\nend",
+  "token": "your_secure_agent_token",
+  "timestamp": "2026-05-22T10:30:00+00:00",
+  "agent_version": "1.0.0"
+}
+```
+
+**Response JSON**:
+```json
+{
+  "status": "ok",
+  "message": "Configuration saved and versioned"
+}
+```
+Oppure:
+```json
+{
+  "status": "ok", 
+  "message": "No changes detected"
+}
+```
+
+**Codici HTTP**:
+- `200`: Successo (controllare `status` nel JSON)
+- `400`: Payload incompleto
+- `401`: Token non valido
+- `405`: Metodo HTTP non consentito
+- `500`: Errore database/server
+
+---
+
+## 🐍 Script Agent Python: Punti Chiave
+
+### Configurazione Dispositivi (`netconfig_devices.yaml`)
+```yaml
+devices:
+  - name: "SW-Core-01"
+    ip: "10.0.0.1"
+    platform: "cisco_ios"  # Mappatura netmiko
+    glpi_id: 123           # ID in glpi_networkdevices
+    username: "${NETCONFIG_DEFAULT_USER}"  # Variabile d'ambiente
+    enable_password: "${NETCONFIG_ENABLE_PASS}"
+    command: "show running-config"
+    delay_factor: 2
+```
+
+### Gestione Errori Robusta
+- Retry logic con backoff per timeout di rete
+- Distinzione tra errori di autenticazione (no retry) e timeout (retry)
+- Logging strutturato con livelli: INFO per successi, WARNING per retry, ERROR per fallimenti
+
+### Ottimizzazioni
+- Invio a GLPI solo se hash diverso dall'ultimo salvato (controllo lato client opzionale)
+- Pulizia output da caratteri di controllo prima dell'invio
+- Supporto per piattaforme multiple tramite mapping `device_type`
+
+---
+
+## 🔄 Massive Actions Supportate
+
+| Action ID | Etichetta UI | Permesso Richiesto | Comportamento |
+|-----------|-------------|-------------------|---------------|
+| `PluginNetconfig\Config:BackupNow` | "Force backup now" | CREATE | Triggera recupero configurazione immediato per dispositivi selezionati |
+| `PluginNetconfig\Config:ExportSelected` | "Export selected" | READ | Genera download file .txt per configurazioni selezionate |
+
+**Implementazione**: Override di `getSpecificMassiveActions()` e `processMassiveActionsForOneItemtype()` in `Config.php`
+
+---
+
+## 🗄️ Schema Database
+
+### Tabella: `glpi_plugin_netconfig_configs`
+```sql
+CREATE TABLE `glpi_plugin_netconfig_configs` (
+  `id` int unsigned NOT NULL AUTO_INCREMENT,
+  `networkdevices_id` int unsigned NOT NULL DEFAULT '0',  -- FK a glpi_networkdevices
+  `config_content` mediumtext NOT NULL,                    -- Cifrato AES-256-GCM
+  `config_hash` char(64) NOT NULL,                         -- SHA256 hex
+  `is_encrypted` tinyint NOT NULL DEFAULT '1',             -- Flag cifratura
+  `created_at` datetime NOT NULL,                          -- Timestamp salvataggio
+  `users_id` int unsigned NOT NULL DEFAULT '0',            -- 0 = system/agent
+  PRIMARY KEY (`id`),
+  KEY `networkdevices_id` (`networkdevices_id`),
+  KEY `created_at` (`created_at`),
+  KEY `config_hash` (`config_hash`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+```
+
+**Note**:
+- `MEDIUMTEXT` supporta config fino a ~16MB (sufficiente per switch/router enterprise)
+- Indici su `networkdevices_id` e `created_at` per query efficienti dello storico
+- `config_hash` indicizzato per rilevamento rapido duplicati
+
+---
+
+## 🎨 Integrazione UI GLPI
+
+### Tab Personalizzato su NetworkEquipment
+- **Posizione**: Scheda aggiuntiva "Config History" nel form di `NetworkEquipment`
+- **Contenuto**: Tabella con data, hash abbreviato, utente, azioni (export, diff)
+- **Diff Visual**: Modal dialog con output HTML di `symfony/diff` (aggiunte in verde, rimozioni in rosso)
+- **Pulsante Trigger**: "Retrieve configuration now" visibile solo a utenti con diritto CREATE
+
+### Template Twig (`config_tab.html.twig`)
+- Uso di helper GLPI: `path()`, `getUserName`, `__()` per traduzioni
+- Sanitizzazione output diff con `|escape('js')` per prevenzione XSS
+- Responsive design con classi Bootstrap native di GLPI 11
+
+---
+
+## 🛠️ Comandi Utili per Sviluppo & Debug
+
+```bash
+# Verifica ambiente GLPI
+php /var/www/glpi/bin/console glpi:version
+php /var/www/glpi/bin/console glpi:system:status
+
+# Installazione plugin
+cd /var/www/glpi/plugins/netconfig
+composer install --no-dev -o
+chown -R www-data:www-data .
+# Poi: UI GLPI > Configurazione > Plugin > Installa
+
+# Test endpoint agent
+curl -X POST http://localhost/glpi/plugins/netconfig/ajax/agent_receive.php \
+  -H "Content-Type: application/json" \
+  -d '{"device_id":123,"config":"test","token":"CHANGE_ME"}'
+
+# Log utili
+tail -f /var/log/glpi/php-errors.log
+tail -f /var/log/glpi_agent_netconfig.log
+journalctl -u glpi-netconfig.service -f
+
+# Verifica cifratura DB
+mysql -e "SELECT config_content FROM glpi_plugin_netconfig_configs LIMIT 1" glpi_db
+# Deve restituire blob cifrato, non testo in chiaro
+```
+
+---
+
+## 🚨 Troubleshooting Ricorrenti
+
+| Sintomo | Causa Probabile | Soluzione |
+|---------|----------------|-----------|
+| `symfony/diff not found` | Cache Composer corrotta o minimum-stability mancante | `composer clear-cache && composer install -vvv` |
+| Agent riceve 401 | Token non configurato o mismatch | Verificare `NETCONFIG_AGENT_TOKEN` in env e payload |
+| Config non salvata ma nessun errore | Hash identico all'ultima versione (nessuna modifica) | Controllare log: messaggio "No changes detected" è normale |
+| Diff non visualizzato | `symfony/diff` non installato o autoload non aggiornato | `composer dump-autoload -o` |
+| Export scarica file vuoto | Permessi insufficienti o config cifrata senza chiave valida | Verificare `crypt_key` in `config_db.php` e diritti profilo |
+| Massive action non appare | Plugin non attivato o hook non registrato | Controllare `setup.php` e stato plugin in UI GLPI |
+
+---
+
+## 📈 Roadmap Futura (Opzionale)
+
+- [ ] Supporto per backup multipli paralleli (queue RabbitMQ/Redis)
+- [ ] Integrazione con GLPI Notifications per alert su config change
+- [ ] Plugin settings UI per configurare token, timeout, piattaforme supportate
+- [ ] Supporto per dispositivi via API REST (non solo SSH)
+- [ ] Reportistica: grafico frequenza modifiche, compliance check
+- [ ] Webhook outbound per integrazione con SIEM/ITSM esterni
+
+---
+
+## 📚 Riferimenti Ufficiali
+
+- [GLPI 11 Developer Documentation](https://glpi-developer-documentation.readthedocs.io/en/11.0/)
+- [GLPI Plugin Development Guidelines](https://github.com/glpi-project/glpi/blob/11.0/DEV/PLUGIN.md)
+- [Netmiko Documentation](https://ktbyers.github.io/netmiko/)
+- [Symfony Diff Component](https://symfony.com/doc/current/components/diff.html)
+- [GLPI REST API Reference](https://github.com/glpi-project/glpi/blob/11.0/apirest.md)
+
+---
+
+> 💡 **Nota per l'Agent AI**: Quando assisti nello sviluppo di questo plugin, priorizza:
+> 1. Conformità alle linee guida GLPI 11 (namespace, strict_types, DBConnection)
+> 2. Sicurezza (cifratura, validazione input, controllo diritti)
+> 3. Performance (query indicizzate, diff calcolato on-demand)
+> 4. Manutenibilità (codice commentato, log chiari, configurazione esterna)
+```
diff --git a/API/classe_api b/API/classe_api
new file mode 100644
index 0000000..871548f
--- /dev/null
+++ b/API/classe_api
@@ -0,0 +1,160 @@
+<?php
+declare(strict_types=1);
+
+namespace PluginNetconfig\Api;
+
+use GuzzleHttp\Client;
+use GuzzleHttp\Exception\RequestException;
+
+class GlpiApiClient
+{
+    private string $baseUrl;
+    private string $appToken;
+    private ?string $sessionToken = null;
+    private Client $httpClient;
+
+    public function __construct(string $baseUrl, string $appToken, string $userToken = null)
+    {
+        $this->baseUrl = rtrim($baseUrl, '/');
+        $this->appToken = $appToken;
+        $this->httpClient = new Client([
+            'base_uri' => $this->baseUrl . '/apirest.php/',
+            'timeout'  => 30.0,
+            'headers'  => [
+                'App-Token' => $this->appToken,
+                'Content-Type' => 'application/json',
+            ],
+        ]);
+
+        if ($userToken) {
+            $this->loginWithUserToken($userToken);
+        }
+    }
+
+    /**
+     * Login con credenziali utente (username + password)
+     */
+    public function login(string $username, string $password): bool
+    {
+        try {
+            $response = $this->httpClient->post('initSession', [
+                'auth' => [$username, $password],
+            ]);
+            $data = json_decode($response->getBody(), true);
+            $this->sessionToken = $data['session_token'] ?? null;
+            return $this->sessionToken !== null;
+        } catch (RequestException $e) {
+            error_log("GLPI API login failed: " . $e->getMessage());
+            return false;
+        }
+    }
+
+    /**
+     * Login con user token (più sicuro, generato in Profilo > API)
+     */
+    public function loginWithUserToken(string $userToken): bool
+    {
+        try {
+            $response = $this->httpClient->post('initSession', [
+                'headers' => ['User-Token' => $userToken],
+            ]);
+            $data = json_decode($response->getBody(), true);
+            $this->sessionToken = $data['session_token'] ?? null;
+            return $this->sessionToken !== null;
+        } catch (RequestException $e) {
+            error_log("GLPI API user-token login failed: " . $e->getMessage());
+            return false;
+        }
+    }
+
+    /**
+     * Logout e distruzione sessione
+     */
+    public function logout(): void
+    {
+        if ($this->sessionToken) {
+            try {
+                $this->httpClient->delete('killSession', [
+                    'headers' => ['Session-Token' => $this->sessionToken],
+                ]);
+            } catch (\Throwable $e) {
+                // Ignora errori in logout
+            }
+            $this->sessionToken = null;
+        }
+    }
+
+    /**
+     * Esegue una chiamata API con retry automatico su token scaduto
+     */
+    private function request(string $method, string $endpoint, array $data = []): ?array
+    {
+        $headers = $this->sessionToken ? ['Session-Token' => $this->sessionToken] : [];
+
+        try {
+            $response = $this->httpClient->request($method, $endpoint, [
+                'headers' => $headers,
+                'json'    => $data,
+            ]);
+            return json_decode($response->getBody(), true);
+        } catch (RequestException $e) {
+            // Se token scaduto (401), tenta refresh e riprova UNA volta
+            if ($e->getResponse()?->getStatusCode() === 401 && $this->sessionToken) {
+                $this->logout();
+                // Qui potresti ricaricare le credenziali da config/vault e fare re-login
+                // Per semplicità, lanciamo eccezione
+                throw new \RuntimeException("GLPI API session expired. Re-authentication required.");
+            }
+            throw $e;
+        }
+    }
+
+    /**
+     * Ottieni dispositivo di rete per ID
+     */
+    public function getNetworkEquipment(int $id): ?array
+    {
+        $result = $this->request('GET', "NetworkEquipment/$id");
+        return $result && !isset($result[0]['error']) ? $result : null;
+    }
+
+    /**
+     * Cerca dispositivi per nome/IP (per mapping agent -> GLPI ID)
+     */
+    public function searchNetworkEquipment(string $nameOrIp): array
+    {
+        $query = [
+            'criteria' => [
+                ['field' => 1, 'searchtype' => 'contains', 'value' => $nameOrIp], // name
+                ['OR' => [
+                    ['field' => 2, 'searchtype' => 'contains', 'value' => $nameOrIp], // ip
+                ]],
+            ],
+            'forcedisplay' => [1, 2, 3], // id, name, ip
+        ];
+
+        $result = $this->request('GET', 'search/NetworkEquipment', ['criteria' => $query]);
+        return $result['data'] ?? [];
+    }
+
+    /**
+     * Invia configurazione al plugin (endpoint personalizzato)
+     */
+    public function sendConfig(int $deviceId, string $config, string $agentToken): bool
+    {
+        $payload = [
+            'device_id' => $deviceId,
+            'config'    => $config,
+            'token'     => $agentToken,
+            'timestamp' => date('c'),
+        ];
+
+        $result = $this->request('POST', 'plugin/netconfig/agent', $payload);
+        return ($result['status'] ?? '') === 'ok';
+    }
+
+    public function __destruct()
+    {
+        $this->logout();
+    }
+}
diff --git a/MEMORY.md b/MEMORY.md
new file mode 100644
index 0000000..1787e94
--- /dev/null
+++ b/MEMORY.md
@@ -0,0 +1,314 @@
+---
+
+# 🧠 MEMORY.md
+
+```markdown
+# 🧠 MEMORY.md - Knowledge Base Progetto NetConfig Plugin
+
+> **Scopo**: Memoria persistente delle decisioni, contesto e apprendimenti per il team di sviluppo  
+> **Progetto**: GLPI 11 Plugin - Network Configuration Backup & Versioning  
+> **Stato**: ✅ Specifica Completa | 🚧 Implementazione Pronta | 🧪 Test in Corso
+
+---
+
+## 📋 Riepilogo Richieste Utente
+
+### Richiesta Originale (Tradotta e Strutturata)
+```
+"Vorrei implementare un plugin per GLPI 11 secondo le linee guida degli sviluppatori GLPI per:
+1. Salvare configurazioni di apparati di rete (es. switch) nel database MySQL
+2. Tenere traccia delle variazioni della configurazione (versioning)
+3. Implementare massive actions (azioni di massa)
+4. Gestire i profili come già integrato in GLPI (ACL native)
+5. Permettere l'esportazione in file di testo del contenuto salvato (solo per utenti con diritti)
+6. Lanciare il comando per recuperare la configurazione dall'apparato di rete
+7. Valutare l'utilizzo di un agent GLPI remoto per eseguire il recupero configurazione
+8. Fornire una proposta architetturale completa"
+```
+
+### Vincoli Espliciti
+- ✅ GLPI 11.0.6+ (verificato con `php bin/console glpi:version`)
+- ✅ PHP 8.2+ con strict_types e namespace PSR-4
+- ✅ MySQL/MariaDB con charset utf8mb4
+- ✅ Integrazione con sistema profili/diritti nativo GLPI
+- ✅ Massive actions compatibili con UI GLPI
+- ✅ Cifratura configurazioni sensibili
+- ✅ Agent remoto opzionale ma preferito per scalabilità
+
+---
+
+## 🗂️ Decisioni Architetturali Confermate
+
+### ✅ Scelte Definitive
+| Area | Decisione | Motivazione |
+|------|-----------|-------------|
+| **Struttura Plugin** | PSR-4 autoload, `src/` per classi, `ajax/` per endpoint | Conformità linee guida GLPI 11, manutenibilità |
+| **Database** | Tabella dedicata `glpi_plugin_netconfig_configs` con MEDIUMTEXT | Isolamento dati, performance query, supporto config grandi |
+| **Versioning** | SHA256 hash + confronto all'arrivo nuovo backup | Rilevamento modifiche efficiente, storage ottimizzato |
+| **Cifratura** | `Glpi\Toolbox\Encryption` (AES-256-GCM) | Integrazione nativa, chiave gestita da GLPI, compliance |
+| **Agent Remoto** | Python + netmiko + YAML config + systemd timer | Supporto multi-vendor maturo, gestione timeout/retry robusta |
+| **Diff Visual** | `symfony/diff` con output HTML sanitizzato per Twig | Libreria mantenuta, output sicuro, integrazione semplice |
+| **Export** | Stream diretto con redaction regex + controllo diritti | Performance, sicurezza, compliance policy aziendali |
+| **API Endpoint** | POST JSON con token + validazione hash lato server | Stateless, compatibile con agent distribuiti, auditabile |
+
+### ❌ Alternative Scartate (con Motivazione)
+| Alternativa | Motivazione Scarto |
+|-------------|-------------------|
+| SSH diretto da PHP (phpseclib) | Timeout frequenti, gestione connessioni concorrenti complessa, scaling limitato |
+| Archiviazione su filesystem | Perdita integrazione ACL GLPI, backup/disaster recovery più complesso, audit difficile |
+| Integrazione Oxidized/RANCID | Overhead infrastrutturale aggiuntivo, duplicazione logica versioning, curva apprendimento team |
+| Agent in PHP invece di Python | Netmiko/napalm hanno supporto multi-vendor più maturo e community attiva in Python |
+| Diff calcolato lato client (JS) | Configurazioni grandi (>1MB) causano lag browser, sanitizzazione complessa per XSS |
+
+---
+
+## 🔐 Security & Compliance Decisions
+
+### Credenziali e Segreti
+```yaml
+# ✅ DO: Usare variabili d'ambiente o vault esterno
+NETCONFIG_DEFAULT_USER: "backup_svc"
+NETCONFIG_DEFAULT_PASS: "${VAULT_SECRET_NETCONFIG_PASS}"
+NETCONFIG_AGENT_TOKEN: "${OPENSSL_GENERATED_32B_HEX}"
+
+# ❌ DON'T: Hardcodare nel codice o YAML
+# password: "SuperSecret123"  # MAI fare questo
+```
+
+### Cifratura Dati
+- **A riposo**: `config_content` cifrato con `Glpi\Toolbox\Encryption::encrypt()`
+- **Chiave**: Derivata da `crypt_key` in `GLPI_CONFIG_DIR/config_db.php` (gestita da GLPI)
+- **Algoritmo**: AES-256-GCM con autenticazione (previene tampering)
+- **Verifica**: Test manuale post-install per confermare che DB contenga blob cifrati
+
+### Controllo Accessi
+```php
+// Pattern confermato per tutti i metodi sensibili
+if (!\PluginNetconfig\Config::canView()) {
+    http_response_code(403);
+    exit('Access denied');
+}
+```
+
+### Redaction Export
+```php
+// Regex per mascherare credenziali prima dell'export
+$content = preg_replace(
+    '/(?<=password\s|secret\s|enable\s|community\s)[^\s\r\n]+/i', 
+    '***REDACTED***', 
+    $content
+);
+// Personalizzabile in base alle policy aziendali
+```
+
+---
+
+## 🧪 Test Plan Confermato
+
+### Test Unitari (PHPUnit - da implementare)
+```php
+// Esempio: test hash detection
+public function testSaveConfig_DetectsNoChanges(): void
+{
+    $config = new \PluginNetconfig\Config();
+    $result = $config->saveConfig([
+        'networkdevices_id' => 123,
+        'content' => 'identical config content'
+    ]);
+    // Primo salvataggio: true
+    // Secondo salvataggio stesso contenuto: true ma nessun nuovo record
+}
+```
+
+### Test di Integrazione
+1. **Installazione plugin**: Verificare creazione tabella e registrazione hook
+2. **Diritti profilo**: Assegnare READ a utente test, verificare accesso a tab Config History
+3. **Agent simulation**: Invio JSON via curl, verificare risposta e record in DB
+4. **Export flow**: Login utente con diritti, click export, verificare download e redaction
+5. **Diff visual**: Salvare due versioni diverse, verificare rendering HTML differenze
+
+### Test di Sicurezza
+```bash
+# 1. Tentativo export senza diritti
+curl -b "glpi_session=invalid" http://glpi/plugins/netconfig/ajax/export.php?id=1
+# Atteso: HTTP 403
+
+# 2. Invio agent con token errato
+curl -X POST ... -d '{"token":"wrong"}'
+# Atteso: {"status":"error","message":"Unauthorized"}
+
+# 3. Verifica cifratura DB
+mysql -e "SELECT config_content FROM glpi_plugin_netconfig_configs LIMIT 1" | head
+# Atteso: blob binario non leggibile, non testo in chiaro
+```
+
+---
+
+## 📦 Dipendenze e Versioni Confermate
+
+### composer.json (Definitivo)
+```json
+{
+  "name": "glpi-plugin/netconfig",
+  "license": "GPL-3.0-or-later",
+  "minimum-stability": "stable",
+  "prefer-stable": true,
+  "require": {
+    "php": ">=8.2",
+    "symfony/diff": "^6.4",
+    "guzzlehttp/guzzle": "^7.8"
+  },
+  "autoload": {
+    "psr-4": {
+      "PluginNetconfig\\": "src/",
+      "PluginNetconfig\\Api\\": "src/Api/"
+    }
+  }
+}
+```
+
+### Requisiti Python Agent
+```txt
+# requirements-agent.txt
+netmiko>=4.3.0
+requests>=2.31.0
+pyyaml>=6.0.1
+cryptography>=41.0.0  # Per eventuale cifratura lato agent (opzionale)
+```
+
+### Estensioni PHP Richieste
+```bash
+php -m | grep -E "curl|json|mbstring|openssl|zip|pdo_mysql"
+# Tutte devono essere presenti per GLPI 11 + plugin
+```
+
+---
+
+## 🔄 Flussi Operativi Documentati
+
+### Flusso 1: Backup Schedulato (Agent Remoto)
+```mermaid
+sequenceDiagram
+    participant Cron as Systemd Timer/Cron
+    participant Agent as GLPI Agent (Python)
+    participant Device as Network Device
+    participant GLPI as GLPI Server + Plugin
+    
+    Cron->>Agent: Trigger ogni 6h
+    Agent->>Device: SSH via netmiko (show running-config)
+    Device-->>Agent: Restituisce configurazione
+    Agent->>Agent: Calcola SHA256, confronta con ultimo locale (opzionale)
+    Agent->>GLPI: POST /ajax/agent_receive.php con JSON
+    GLPI->>GLPI: Valida token, decifra chiave, confronta hash DB
+    alt Hash diverso
+        GLPI->>GLPI: Cifra contenuto, salva nuovo record, registra versione
+        GLPI-->>Agent: {"status":"ok","message":"Saved"}
+    else Hash identico
+        GLPI-->>Agent: {"status":"ok","message":"No changes"}
+    end
+    Agent->>Cron: Log risultato, exit
+```
+
+### Flusso 2: Export Configurazione (Utente GLPI)
+```mermaid
+sequenceDiagram
+    participant User as Utente GLPI
+    participant UI as Interfaccia GLPI
+    participant Plugin as Plugin NetConfig
+    participant DB as Database MySQL
+    
+    User->>UI: Clicca "Export" su configurazione
+    UI->>Plugin: GET /ajax/export.php?id=XXX
+    Plugin->>Plugin: Verifica Session::haveRight(Config::READ)
+    alt Diritti insufficienti
+        Plugin-->>UI: HTTP 403 + messaggio errore
+    else Diritti OK
+        Plugin->>DB: SELECT config_content, is_encrypted WHERE id=XXX
+        DB-->>Plugin: Restituisce record
+        Plugin->>Plugin: Decifra se is_encrypted=1
+        Plugin->>Plugin: Applica regex redaction su password/secret
+        Plugin-->>User: HTTP 200 + file .txt in download
+    end
+```
+
+### Flusso 3: Visualizzazione Diff (UI GLPI)
+```mermaid
+sequenceDiagram
+    participant User as Utente GLPI
+    participant Twig as Template Engine
+    participant Plugin as Plugin NetConfig
+    participant DiffLib as symfony/diff
+    
+    User->>UI: Apri tab "Config History" su NetworkEquipment
+    UI->>Plugin: Richiedi liste configurazioni per device_id
+    Plugin->>DB: SELECT * ORDER BY created_at DESC
+    DB-->>Plugin: Restituisce array configurazioni
+    Plugin->>Plugin: Per l'ultima config, carica precedente e calcola diff
+    Plugin->>DiffLib: Differ::diff(old, new) con HtmlOutput
+    DiffLib-->>Plugin: Stringa HTML con <ins>/<del>
+    Plugin->>Twig: Passa configs + diff_html al template
+    Twig->>User: Renderizza tabella con pulsante "View Diff"
+    User->>UI: Clicca pulsante diff
+    UI->>User: Modal dialog con differenze evidenziate (verde/rosso)
+```
+
+---
+
+## 🚨 Lessons Learned & Pitfalls Evitati
+
+### ✅ Cosa Abbiamo Imparato
+1. **Composer in ambienti non-standard**: Il warning `installed.json not found` è innocuo se `composer install` completa con successo. Non bloccare l'installazione per questo.
+2. **Hash vs Timestamp per versioning**: Confrontare hash SHA256 è più affidabile dei timestamp (orologi non sincronizzati, config identiche con timestamp diversi).
+3. **Cifratura nativa GLPI**: Usare `Glpi\Toolbox\Encryption` evita di gestire chiavi separatamente e garantisce compatibilità con backup/restore GLPI.
+4. **Diff on-demand**: Calcolare il diff solo per l'ultima configurazione (non per tutto lo storico) migliora le performance con config grandi.
+5. **Agent token rotation**: Documentare la procedura di rotazione token nel README operativo, anche se non implementata nel codice.
+
+### ⚠️ Pitfalls Evitati
+| Problema Potenziale | Come Lo Abbiamo Evitato |
+|---------------------|------------------------|
+| XSS nel diff HTML | Output di `symfony/diff` sanitizzato con `|escape('js')` in Twig |
+| SQL injection in massive actions | Uso di prepared statements in `getLastConfigByDevice()` |
+| Credential leak nei log | Logging configurato per escludere payload config, solo metadata |
+| Timeout SSH su dispositivi lenti | Retry logic con backoff + `global_delay_factor` configurabile per device |
+| Memory exhaustion con config grandi | Stream export invece di caricamento intero in memoria, uso di `MEDIUMTEXT` |
+
+---
+
+## 📞 Contatti e Responsabilità
+
+| Ruolo | Responsabilità | Contatto (Esempio) |
+|-------|---------------|-------------------|
+| **Plugin Maintainer** | Release, compatibilità GLPI, security patch | team-dev@azienda.it |
+| **Agent Operator** | Deploy script Python, gestione dispositivi YAML, monitoraggio | netops@azienda.it |
+| **Security Officer** | Approvazione policy redaction, rotazione token, audit cifratura | security@azienda.it |
+| **GLPI Admin** | Installazione plugin, gestione profili, backup database | glpi-admin@azienda.it |
+
+---
+
+## 🗓️ Cronologia Decisioni
+
+| Data | Decisione | Autore | Riferimento |
+|------|-----------|--------|-------------|
+| 2026-05-22 | Architettura plugin confermata (PSR-4, encryption nativa, agent Python) | AI Assistant + Utente | Richiesta iniziale |
+| 2026-05-22 | Scelta symfony/diff ^6.4 per visualizzazione differenze | AI Assistant | Valutazione librerie |
+| 2026-05-22 | Token-based auth per endpoint agent invece di session GLPI | AI Assistant | Requisito agent remoto |
+| 2026-05-22 | Redaction automatica password in export tramite regex | AI Assistant | Compliance sicurezza |
+| 2026-05-22 | Supporto massive actions native invece di UI custom | AI Assistant | Integrazione UX GLPI |
+
+---
+
+## 🔗 Link Utili per il Team
+
+- [Repository Plugin (interno)](https://git.azienda.it/glpi-plugins/netconfig)
+- [Documentazione GLPI 11 Developer](https://glpi-developer-documentation.readthedocs.io/en/11.0/)
+- [Netmiko Platform Support](https://github.com/ktbyers/netmiko/blob/develop/PLATFORMS.md)
+- [GLPI API Postman Collection](https://github.com/glpi-project/glpi/blob/11.0/apirest.md)
+- [Checklist Sicurezza Plugin GLPI](https://github.com/glpi-project/glpi/blob/11.0/DEV/SECURITY.md)
+
+---
+
+> 📌 **Nota Operativa**: Questo documento va aggiornato ad ogni modifica architetturale significativa.  
+> **Ultima revisione**: 2026-05-22 | **Prossima review pianificata**: 2026-08-22
+```
+
+---
diff --git a/REPORT.md b/REPORT.md
new file mode 100644
index 0000000..ec9df53
--- /dev/null
+++ b/REPORT.md
@@ -0,0 +1,1301 @@
+# 📦 Plugin GLPI 11: Network Config Backup (`netconfig`)
+
+> **Compatibilità**: GLPI 11.0.6+ | PHP 8.2+ | MySQL/MariaDB  
+> **Autore**: Your Name / Team | **Licenza**: GPL-3.0-or-later  
+> **Ultimo aggiornamento**: 2026
+
+---
+
+## 📋 Indice
+1. [Architettura del Plugin](#-1-architettura-del-plugin)
+2. [Struttura File](#-2-struttura-file)
+3. [Codice Completo dei File](#-3-codice-completo-dei-file)
+4. [Script Python per GLPI Agent](#-4-script-python-per-glpi-agent)
+5. [Configurazione Scheduler (Cron/Supervisor/Systemd)](#-5-configurazione-scheduler)
+6. [Client API REST GLPI 11](#-6-client-api-rest-glpi-11)
+7. [Installazione Passo-Passo](#-7-installazione-passo-passo)
+8. [Risoluzione Problemi Composer](#-8-risoluzione-problemi-composer)
+9. [Sicurezza e Best Practice](#-9-sicurezza-e-best-practice)
+10. [Checklist Finale di Deploy](#-10-checklist-finale-di-deploy)
+
+---
+
+## 🧱 1. Architettura del Plugin
+
+```
+plugins/netconfig/
+├── setup.php                     # Registrazione plugin, hook, versioning
+├── hook.php                      # Hook install/uninstall
+├── composer.json                 # Dipendenze (PSR-4, symfony/diff, guzzle)
+├── install/
+│   └── mysql/
+│       └── install.sql           # Schema database
+├── src/
+│   ├── Config.php                # Classe CommonDBTM: CRUD, massive actions, diff
+│   └── Agent/
+│       └── Receive.php           # Endpoint API per ricezione da agent
+├── ajax/
+│   ├── export.php                # Download sicuro configurazioni
+│   └── agent_receive.php         # Fallback endpoint agent
+├── templates/
+│   └── config_tab.html.twig      # Vista tab GLPI con storico e azioni
+├── locales/
+│   ├── en_GB.po
+│   └── it_IT.po
+└── README.md                     # Questo file
+```
+
+---
+
+## 📁 2. Struttura File (Riepilogo)
+
+| File | Scopo | Note |
+|------|-------|------|
+| `setup.php` | Inizializzazione plugin, hook, diritti | Conforme GLPI 11 |
+| `hook.php` | Installazione/rimozione tabelle DB | Usa `DBConnection` |
+| `composer.json` | Dipendenze e autoloading PSR-4 | Richiede `composer install` |
+| `install/mysql/install.sql` | Creazione tabella `glpi_plugin_netconfig_configs` | InnoDB, utf8mb4 |
+| `src/Config.php` | Logica business: salvataggio, versioning, diff, massive actions | Estende `CommonDBTM` |
+| `src/Agent/Receive.php` | Endpoint API per ricezione config da agent | Validazione token, hash, cifratura |
+| `ajax/export.php` | Export configurazioni in formato testo | Controllo diritti, redaction password |
+| `ajax/agent_receive.php` | Endpoint fallback per agent (se API REST non attiva) | Session-based auth |
+| `templates/config_tab.html.twig` | Template Twig per visualizzazione storico | Integrazione nativa GLPI |
+| `netconfig_backup.py` | Script Python per GLPI Agent (esterno al plugin) | Netmiko, YAML config, retry logic |
+| `glpi-netconfig.service/timer` | Unit systemd per esecuzione schedulata | Alternativa a cron/supervisor |
+| `GlpiApiClient.php` | Client PHP per API REST GLPI 11 | App-Token + Session-Token, retry |
+
+---
+
+## 💻 3. Codice Completo dei File
+
+### 🔹 `setup.php`
+```php
+<?php
+declare(strict_types=1);
+
+define('PLUGIN_NETCONFIG_VERSION', '1.0.0');
+define('PLUGIN_NETCONFIG_NAME', 'netconfig');
+
+function plugin_init_netconfig() {
+    global $PLUGIN_HOOKS;
+
+    $PLUGIN_HOOKS['csrf_compliant']['netconfig'] = true;
+    $PLUGIN_HOOKS['compatible']['netconfig'] = ['glpi' => '>=11.0'];
+
+    // Integrazione menu GLPI
+    $PLUGIN_HOOKS['menu_toadd']['netconfig'] = [
+        'tools' => \PluginNetconfig\Config::class,
+    ];
+
+    // Registrazione endpoint API per l'agent
+    $PLUGIN_HOOKS['add_api_endpoint']['netconfig'] = [
+        '/plugin/netconfig/agent' => 'PluginNetconfig\Agent\Receive',
+    ];
+
+    // Attivazione massive actions
+    $PLUGIN_HOOKS['use_massive_actions']['netconfig'] = true;
+
+    // Registrazione automatica dei diritti profilo
+    if (class_exists('\PluginNetconfig\Config')) {
+        $PLUGIN_HOOKS['add_javascript']['netconfig'][] = 'netconfig.js'; // Opzionale
+    }
+}
+
+function plugin_version_netconfig() {
+    return [
+        'name'         => 'Network Config Backup',
+        'version'      => PLUGIN_NETCONFIG_VERSION,
+        'author'       => 'Your Name / Team',
+        'license'      => 'GPL-3.0-or-later',
+        'homepage'     => '',
+        'requirements' => [
+            'glpi' => ['min' => '11.0.0', 'max' => '11.99.99'],
+            'php'  => ['min' => '8.2.0'],
+        ],
+    ];
+}
+
+function plugin_install_netconfig() {
+    return true;
+}
+
+function plugin_uninstall_netconfig() {
+    return true;
+}
+```
+
+---
+
+### 🔹 `hook.php`
+```php
+<?php
+declare(strict_types=1);
+
+use DBConnection;
+
+function plugin_netconfig_install() {
+    $db = DBConnection::getReadConnection();
+    $sql = file_get_contents(__DIR__ . '/install/mysql/install.sql');
+    $db->doQuery($sql);
+    return true;
+}
+
+function plugin_netconfig_uninstall() {
+    $db = DBConnection::getReadConnection();
+    $db->doQuery("DROP TABLE IF EXISTS `glpi_plugin_netconfig_configs`");
+    return true;
+}
+```
+
+---
+
+### 🔹 `composer.json`
+```json
+{
+  "name": "glpi-plugin/netconfig",
+  "description": "Backup e versioning configurazioni di rete per GLPI 11",
+  "type": "glpi-plugin",
+  "license": "GPL-3.0-or-later",
+  "minimum-stability": "stable",
+  "prefer-stable": true,
+  "require": {
+    "php": ">=8.2",
+    "symfony/diff": "^6.4",
+    "guzzlehttp/guzzle": "^7.8"
+  },
+  "autoload": {
+    "psr-4": {
+      "PluginNetconfig\\": "src/",
+      "PluginNetconfig\\Api\\": "src/Api/"
+    }
+  },
+  "config": {
+    "optimize-autoloader": true,
+    "allow-plugins": {
+      "php-http/discovery": true
+    }
+  }
+}
+```
+
+> ⚠️ **Esegui**: `cd /path/to/glpi/plugins/netconfig && composer install --no-dev -o`
+
+---
+
+### 🔹 `install/mysql/install.sql`
+```sql
+CREATE TABLE IF NOT EXISTS `glpi_plugin_netconfig_configs` (
+  `id` int unsigned NOT NULL AUTO_INCREMENT,
+  `networkdevices_id` int unsigned NOT NULL DEFAULT '0',
+  `config_content` mediumtext NOT NULL,
+  `config_hash` char(64) NOT NULL,
+  `is_encrypted` tinyint NOT NULL DEFAULT '1',
+  `created_at` datetime NOT NULL,
+  `users_id` int unsigned NOT NULL DEFAULT '0',
+  PRIMARY KEY (`id`),
+  KEY `networkdevices_id` (`networkdevices_id`),
+  KEY `created_at` (`created_at`),
+  KEY `config_hash` (`config_hash`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+```
+
+---
+
+### 🔹 `src/Config.php`
+```php
+<?php
+declare(strict_types=1);
+
+namespace PluginNetconfig;
+
+use CommonDBTM;
+use CommonGLPI;
+use Session;
+use MassiveAction;
+use DBConnection;
+use Glpi\Toolbox\Encryption;
+use Symfony\Component\Diff\Differ;
+use Symfony\Component\Diff\Output\HtmlOutput;
+use Glpi\Templating\Twig\TemplateRenderer;
+
+class Config extends CommonDBTM
+{
+    static $rightname = 'plugin_netconfig';
+
+    public static function getTypeName($nb = 0): string
+    {
+        return __('Network Configurations', 'netconfig');
+    }
+
+    public static function getRights($interface = 'central'): array
+    {
+        return [
+            READ   => __('Read'),
+            UPDATE => __('Update'),
+            CREATE => __('Create'),
+            PURGE  => __('Delete permanently'),
+        ];
+    }
+
+    public static function canView(): bool { return Session::haveRight(self::$rightname, READ); }
+    public static function canCreate(): bool { return Session::haveRight(self::$rightname, CREATE); }
+    public static function canUpdate(): bool { return Session::haveRight(self::$rightname, UPDATE); }
+    public static function canPurge(): bool { return Session::haveRight(self::$rightname, PURGE); }
+
+    public function getTabNameForItem(CommonGLPI $item, $withtemplate = 0): string
+    {
+        if ($item->getType() === 'NetworkEquipment' && self::canView()) {
+            return __('Config History', 'netconfig') . ' (' . countElementsInTable(self::getTable(), ['networkdevices_id' => $item->getID()]) . ')';
+        }
+        return '';
+    }
+
+    public static function displayTabContentForItem(CommonGLPI $item, $tabnum = 1, $withtemplate = 0): bool
+    {
+        if ($item->getType() !== 'NetworkEquipment') return true;
+
+        $configs = (new self())->find(
+            ['networkdevices_id' => $item->getID()],
+            'created_at DESC'
+        );
+
+        // Calcola diff per l'ultima config (opzionale, performance-aware)
+        if (!empty($configs)) {
+            $latest = new self();
+            $latest->getFromDB(reset($configs)['id']);
+            $configs[0]['diff_html'] = $latest->getDiffFromPrevious();
+        }
+
+        $twig = new TemplateRenderer();
+        echo $twig->render('@netconfig/config_tab.html.twig', [
+            'configs' => $configs,
+            'can_export' => self::canView(),
+            'can_create' => self::canCreate()
+        ]);
+        return true;
+    }
+
+    public static function getLastConfigByDevice(int $networkdevices_id): ?array
+    {
+        $db = DBConnection::getReadConnection();
+        $stmt = $db->prepare("SELECT * FROM " . self::getTable() . " WHERE networkdevices_id = ? ORDER BY created_at DESC LIMIT 1");
+        $stmt->bind_param('i', $networkdevices_id);
+        $stmt->execute();
+        $result = $stmt->get_result()->fetch_assoc();
+        $stmt->close();
+        return $result ?: null;
+    }
+
+    public static function saveConfig(array $data): bool
+    {
+        $config = new self();
+        $hash = hash('sha256', $data['content']);
+        $last = self::getLastConfigByDevice($data['networkdevices_id']);
+
+        if ($last && $last['config_hash'] === $hash) {
+            return true; // Nessuna modifica rilevata
+        }
+
+        $input = [
+            'networkdevices_id' => $data['networkdevices_id'],
+            'config_content'    => Encryption::encrypt($data['content']),
+            'config_hash'       => $hash,
+            'users_id'          => $data['users_id'] ?? Session::getLoginUserID() ?: 0,
+            'is_encrypted'      => 1,
+        ];
+
+        return $config->add($input) !== false;
+    }
+
+    public function getDecryptedContent(): string
+    {
+        return $this->fields['is_encrypted']
+            ? Encryption::decrypt($this->fields['config_content'])
+            : $this->fields['config_content'];
+    }
+
+    public function getDiffFromPrevious(): string
+    {
+        $last = self::getLastConfigByDevice($this->fields['networkdevices_id']);
+        if (!$last || $last['id'] === $this->fields['id']) return '';
+
+        $prev = new self();
+        $prev->getFromDB($last['id']);
+        $differ = new Differ(new HtmlOutput());
+        return $differ->diff($prev->getDecryptedContent(), $this->getDecryptedContent());
+    }
+
+    // MASSIVE ACTIONS
+    public function getSpecificMassiveActions($checkitem = null): array
+    {
+        $actions = parent::getSpecificMassiveActions($checkitem);
+        if (self::canCreate()) {
+            $actions[self::class . ':BackupNow'] = __('Force backup now', 'netconfig');
+        }
+        if (self::canView()) {
+            $actions[self::class . ':ExportSelected'] = __('Export selected', 'netconfig');
+        }
+        return $actions;
+    }
+
+    public static function processMassiveActionsForOneItemtype(MassiveAction $ma, CommonDBTM $item, array $ids): void
+    {
+        switch ($ma->getAction()) {
+            case self::class . ':BackupNow':
+                foreach ($ids as $id) {
+                    // Trigger agente o coda asincrona
+                    // Esempio: Http::post() verso endpoint agent
+                    $ma->itemDone($item::getType(), $id, MassiveAction::ACTION_OK);
+                }
+                break;
+            case self::class . ':ExportSelected':
+                foreach ($ids as $id) {
+                    // Redirect a export.php con ID
+                    $ma->itemDone($item::getType(), $id, MassiveAction::ACTION_OK);
+                }
+                break;
+        }
+    }
+}
+```
+
+---
+
+### 🔹 `src/Agent/Receive.php`
+```php
+<?php
+declare(strict_types=1);
+
+namespace PluginNetconfig\Agent;
+
+use PluginNetconfig\Config;
+use Glpi\Toolbox\Encryption;
+
+class Receive
+{
+    public function __invoke(array $input, string $method, string $route): array
+    {
+        header('Content-Type: application/json');
+
+        if ($method !== 'POST') {
+            http_response_code(405);
+            return ['status' => 'error', 'message' => 'Method not allowed'];
+        }
+
+        // Validazione payload
+        if (!isset($input['device_id'], $input['config'], $input['token'])) {
+            http_response_code(400);
+            return ['status' => 'error', 'message' => 'Missing required fields: device_id, config, token'];
+        }
+
+        // Validazione token (configurare in .env o config GLPI)
+        $validToken = $_ENV['NETCONFIG_AGENT_TOKEN'] ?? getenv('NETCONFIG_AGENT_TOKEN') ?? 'change_me_in_production';
+        if ($input['token'] !== $validToken) {
+            http_response_code(401);
+            return ['status' => 'error', 'message' => 'Unauthorized: invalid token'];
+        }
+
+        $hash = hash('sha256', $input['config']);
+        $last = Config::getLastConfigByDevice((int)$input['device_id']);
+
+        if ($last && $last['config_hash'] === $hash) {
+            return ['status' => 'ok', 'message' => 'No changes detected'];
+        }
+
+        $config = new Config();
+        $data = [
+            'networkdevices_id' => (int)$input['device_id'],
+            'config_content'    => Encryption::encrypt($input['config']),
+            'config_hash'       => $hash,
+            'users_id'          => 0, // Agent/System
+            'is_encrypted'      => 1,
+        ];
+
+        if ($config->add($data) !== false) {
+            return ['status' => 'ok', 'message' => 'Configuration saved and versioned'];
+        }
+
+        http_response_code(500);
+        return ['status' => 'error', 'message' => 'Database insertion failed'];
+    }
+}
+```
+
+---
+
+### 🔹 `ajax/agent_receive.php`
+```php
+<?php
+declare(strict_types=1);
+include('../../../inc/includes.php');
+
+header('Content-Type: application/json');
+Session::checkLoginUser();
+
+$input = json_decode(file_get_contents('php://input'), true);
+if (!is_array($input)) {
+    http_response_code(400);
+    echo json_encode(['status' => 'error', 'message' => 'Invalid JSON']);
+    exit;
+}
+
+$handler = new \PluginNetconfig\Agent\Receive();
+echo json_encode($handler($input, 'POST', '/plugin/netconfig/agent'));
+exit;
+```
+
+---
+
+### 🔹 `ajax/export.php`
+```php
+<?php
+declare(strict_types=1);
+include('../../../inc/includes.php');
+
+header("Content-Type: application/octet-stream");
+header("Pragma: no-cache");
+Html::header_nocache();
+
+$id = (int)($_GET['id'] ?? 0);
+if (!$id || !\PluginNetconfig\Config::canView()) {
+    http_response_code(403);
+    exit('Access denied');
+}
+
+$config = new \PluginNetconfig\Config();
+if (!$config->getFromDB($id)) {
+    http_response_code(404);
+    exit('Configuration not found');
+}
+
+$content = $config->getDecryptedContent();
+
+// Opzionale: mascheramento credenziali sensibili
+$content = preg_replace('/(?<=password\s|secret\s|enable\s|community\s)[^\s\r\n]+/i', '***REDACTED***', $content);
+
+header('Content-Disposition: attachment; filename="netconfig_' . $id . '_' . date('Ymd_His') . '.txt"');
+echo $content;
+exit;
+```
+
+---
+
+### 🔹 `templates/config_tab.html.twig`
+```twig
+<div class="card">
+  <div class="card-body">
+    <table class="tab_cadre_fixehov">
+      <thead>
+        <tr>
+          <th>{{ __('Date') }}</th>
+          <th>{{ __('Hash') }}</th>
+          <th>{{ __('User') }}</th>
+          <th>{{ __('Actions') }}</th>
+        </tr>
+      </thead>
+      <tbody>
+        {% for config in configs %}
+        <tr class="tab_bg_1">
+          <td>{{ config.created_at }}</td>
+          <td><code>{{ config.config_hash|slice(0, 16) }}...</code></td>
+          <td>{{ config.users_id > 0 ? config.users_id|getUserName : __('System') }}</td>
+          <td>
+            <div class="btn-group btn-group-sm">
+              {% if can_export %}
+              <a href="{{ path('/plugins/netconfig/ajax/export.php') }}?id={{ config.id }}" 
+                 class="btn btn-outline-primary" 
+                 title="{{ __('Export as text file') }}">
+                <i class="fas fa-download"></i>
+              </a>
+              {% endif %}
+              {% if config.diff_html is defined and config.diff_html is not empty %}
+              <button class="btn btn-outline-info" 
+                      onclick="GlpiDisplayDialog('diff_{{ config.id }}', '{{ __('Configuration Diff') }}', '{{ config.diff_html|escape('js') }}')"
+                      title="{{ __('View changes from previous version') }}">
+                <i class="fas fa-code-compare"></i>
+              </button>
+              {% endif %}
+            </div>
+          </td>
+        </tr>
+        {% else %}
+        <tr class="tab_bg_1">
+          <td colspan="4" class="center text-muted">
+            {{ __('No configuration saved yet') }}
+          </td>
+        </tr>
+        {% endfor %}
+      </tbody>
+    </table>
+    
+    {% if can_create %}
+    <div class="mt-3 text-end">
+      <button class="btn btn-primary" onclick="Netconfig.triggerBackup({{ item.fields.id }})">
+        <i class="fas fa-sync-alt"></i> {{ __('Retrieve configuration now') }}
+      </button>
+    </div>
+    {% endif %}
+  </div>
+</div>
+
+<script>
+var Netconfig = {
+  triggerBackup: function(deviceId) {
+    $.ajax({
+      url: CFG_GLPI.root_doc + '/plugins/netconfig/ajax/trigger_backup.php',
+      method: 'POST',
+      data: {
+        devices_id: deviceId,
+        _glpi_csrf_token: CFG_GLPI.csrf_token
+      },
+      success: function(response) {
+        if (response.status === 'ok') {
+          addMessageAfterRedirect('Backup triggered successfully', false, INFO);
+          setTimeout(() => location.reload(), 2000);
+        } else {
+          addMessageAfterRedirect(response.message || 'Error triggering backup', true, ERROR);
+        }
+      },
+      error: function() {
+        addMessageAfterRedirect('AJAX error', true, ERROR);
+      }
+    });
+  }
+};
+</script>
+```
+
+---
+
+## 🐍 4. Script Python per GLPI Agent (`netconfig_backup.py`)
+
+> Posiziona in `/usr/share/glpi-agent/plugins/` o cartella task personalizzate.
+
+```python
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+GLPI Agent Task: netconfig_backup
+Recupera configurazione da apparati di rete e invia a GLPI plugin netconfig
+Requisiti: netmiko, requests, pyyaml
+Install: pip3 install netmiko requests pyyaml
+"""
+
+import os
+import sys
+import json
+import hashlib
+import logging
+import requests
+from datetime import datetime, timezone
+from typing import Optional, Dict, List
+from netmiko import ConnectHandler, NetmikoTimeoutException, NetmikoAuthenticationException
+import yaml
+
+# Configurazione logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('/var/log/glpi_agent_netconfig.log'),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger('netconfig_backup')
+
+# Configurazione da variabili d'ambiente o file YAML esterno
+CONFIG_FILE = os.getenv('NETCONFIG_CONFIG', '/etc/glpi-agent/netconfig_devices.yaml')
+GLPI_URL = os.getenv('GLPI_URL', 'http://localhost/glpi')
+GLPI_APP_TOKEN = os.getenv('GLPI_APP_TOKEN', '')
+AGENT_TOKEN = os.getenv('NETCONFIG_AGENT_TOKEN', 'change_me_in_production')
+TIMEOUT = int(os.getenv('NETCONFIG_TIMEOUT', '30'))
+RETRIES = int(os.getenv('NETCONFIG_RETRIES', '2'))
+SSL_VERIFY = os.getenv('SSL_VERIFY', 'true').lower() == 'true'
+
+
+def load_devices_config(path: str) -> List[Dict]:
+    """Carica configurazione dispositivi da YAML"""
+    if not os.path.exists(path):
+        logger.error(f"Config file not found: {path}")
+        return []
+    
+    try:
+        with open(path, 'r') as f:
+            data = yaml.safe_load(f)
+        return data.get('devices', [])
+    except Exception as e:
+        logger.error(f"Error loading config: {e}")
+        return []
+
+
+def get_device_connection_params(device: Dict) -> Dict:
+    """Prepara parametri di connessione per netmiko"""
+    device_type_map = {
+        'cisco_ios': 'cisco_ios',
+        'cisco_nxos': 'cisco_nxos',
+        'hp_comware': 'hp_comware',
+        'juniper_junos': 'juniper_junos',
+        'arista_eos': 'arista_eos',
+        'paloalto_panos': 'paloalto_panos',
+        'fortinet': 'fortinet',
+    }
+    
+    return {
+        'device_type': device_type_map.get(device['platform'], 'cisco_ios'),
+        'host': device['ip'],
+        'username': device.get('username', os.getenv('NETCONFIG_DEFAULT_USER')),
+        'password': device.get('password', os.getenv('NETCONFIG_DEFAULT_PASS')),
+        'secret': device.get('enable_password', os.getenv('NETCONFIG_ENABLE_PASS')),
+        'port': device.get('port', 22),
+        'timeout': TIMEOUT,
+        'session_log': None,
+        'global_delay_factor': device.get('delay_factor', 1),
+        'auth_timeout': 10,
+    }
+
+
+def fetch_config(device: Dict) -> Optional[str]:
+    """Recupera configurazione via SSH con netmiko"""
+    params = get_device_connection_params(device)
+    
+    for attempt in range(RETRIES + 1):
+        try:
+            logger.info(f"Connecting to {device['name']} ({params['host']}) [attempt {attempt+1}/{RETRIES+1}]")
+            connection = ConnectHandler(**params)
+            
+            # Abilita modalità enable se necessaria
+            if params.get('secret'):
+                connection.enable()
+            
+            # Comando di show config (personalizzabile per piattaforma)
+            command = device.get('command', 'show running-config')
+            config = connection.send_command(command, expect_string=r'#|\$', max_loops=150)
+            
+            connection.disconnect()
+            
+            # Pulizia output da caratteri di controllo e spazi finali
+            config = config.strip()
+            config = '\n'.join(line.rstrip() for line in config.splitlines())
+            
+            logger.info(f"✓ Config fetched successfully for {device['name']} ({len(config)} bytes)")
+            return config
+            
+        except NetmikoAuthenticationException as e:
+            logger.error(f"✗ Auth failed for {device['name']}: {e}")
+            break  # Non ritentare se auth fallisce
+        except NetmikoTimeoutException as e:
+            logger.warning(f"⚠ Timeout for {device['name']}: {e}")
+        except Exception as e:
+            logger.error(f"✗ Unexpected error for {device['name']}: {type(e).__name__}: {e}")
+            if attempt < RETRIES:
+                logger.info(f"Retrying in 5s...")
+                import time; time.sleep(5)
+    
+    return None
+
+
+def send_to_glpi(device_id: int, config: str) -> bool:
+    """Invia configurazione a GLPI plugin endpoint"""
+    url = f"{GLPI_URL}/plugins/netconfig/ajax/agent_receive.php"
+    
+    payload = {
+        'device_id': device_id,
+        'config': config,
+        'token': AGENT_TOKEN,
+        'timestamp': datetime.now(timezone.utc).isoformat(),
+        'agent_version': '1.0.0',
+        'agent_hostname': os.getenv('HOSTNAME', 'unknown')
+    }
+    
+    headers = {
+        'Content-Type': 'application/json',
+    }
+    if GLPI_APP_TOKEN:
+        headers['App-Token'] = GLPI_APP_TOKEN
+    
+    try:
+        response = requests.post(
+            url,
+            json=payload,
+            headers=headers,
+            timeout=30,
+            verify=SSL_VERIFY
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            logger.info(f"GLPI response: {result.get('message', 'OK')}")
+            return result.get('status') == 'ok'
+        else:
+            logger.error(f"GLPI HTTP {response.status_code}: {response.text[:200]}")
+            return False
+            
+    except requests.RequestException as e:
+        logger.error(f"Request to GLPI failed: {type(e).__name__}: {e}")
+        return False
+
+
+def calculate_hash(config: str) -> str:
+    """Calcola SHA256 della configurazione"""
+    return hashlib.sha256(config.encode('utf-8')).hexdigest()
+
+
+def run_task():
+    """Entry point della task"""
+    logger.info("=== NetConfig Backup Task Started ===")
+    
+    devices = load_devices_config(CONFIG_FILE)
+    if not devices:
+        logger.warning("No devices configured, exiting")
+        return
+    
+    success_count = 0
+    fail_count = 0
+    
+    for device in devices:
+        try:
+            device_name = device.get('name', 'unknown')
+            device_id = device.get('glpi_id')  # ID in glpi_networkdevices
+            
+            if not device_id:
+                logger.warning(f"⚠ Skipping {device_name}: missing glpi_id")
+                continue
+            
+            config = fetch_config(device)
+            if not config:
+                logger.warning(f"✗ Failed to fetch config for {device_name}")
+                fail_count += 1
+                continue
+            
+            if send_to_glpi(device_id, config):
+                success_count += 1
+                logger.info(f"✓ {device_name} - Config saved")
+            else:
+                logger.error(f"✗ {device_name} - Failed to save to GLPI")
+                fail_count += 1
+                
+        except Exception as e:
+            logger.exception(f"✗ Unhandled error for device {device.get('name')}: {e}")
+            fail_count += 1
+    
+    logger.info(f"=== Task Completed: {success_count} OK, {fail_count} FAILED / {len(devices)} total ===")
+
+
+if __name__ == '__main__':
+    run_task()
+```
+
+---
+
+### 🔹 File di configurazione dispositivi: `/etc/glpi-agent/netconfig_devices.yaml`
+```yaml
+# Esempio configurazione dispositivi per netconfig_backup.py
+# Permessi file: chmod 600 /etc/glpi-agent/netconfig_devices.yaml
+# Suggerimento: usare vault esterno per password (es. HashiCorp Vault, AWS Secrets Manager)
+
+devices:
+  - name: "SW-Core-01"
+    ip: "10.0.0.1"
+    platform: "cisco_ios"
+    glpi_id: 123  # ID in glpi_networkdevices
+    username: "backup_user"
+    # password: "xxx"  # ⚠️ Non inserire password in chiaro! Usa variabili d'ambiente
+    enable_password: "enable_secret"
+    command: "show running-config"
+    delay_factor: 2
+    timeout: 45
+
+  - name: "SW-Access-05"
+    ip: "10.0.0.5"
+    platform: "hp_comware"
+    glpi_id: 124
+    username: "admin"
+    command: "display current-configuration"
+    port: 2222
+
+  - name: "FW-Edge-01"
+    ip: "10.0.0.254"
+    platform: "paloalto_panos"
+    glpi_id: 125
+    username: "api_user"
+    command: "show config running"
+```
+
+> 🔐 **Best Practice per le credenziali**:
+> ```bash
+> # In /etc/environment o systemd service file:
+> export NETCONFIG_DEFAULT_USER="backup_user"
+> export NETCONFIG_DEFAULT_PASS="$(cat /run/secrets/netconfig_pass)"
+> export NETCONFIG_ENABLE_PASS="$(vault kv get -field=enable netconfig)"
+> ```
+
+---
+
+## ⏱️ 5. Configurazione Scheduler
+
+### 🔸 Opzione A: Cron (semplice)
+```bash
+# /etc/cron.d/glpi-netconfig
+# Esegui backup ogni 6 ore (02:00, 08:00, 14:00, 20:00)
+SHELL=/bin/bash
+PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin
+
+0 2,8,14,20 * * * glpi-agent /usr/bin/python3 /usr/share/glpi-agent/plugins/netconfig_backup.py >> /var/log/glpi_netconfig_cron.log 2>&1
+```
+
+### 🔸 Opzione B: Supervisor (controllo processi)
+```ini
+# /etc/supervisor/conf.d/glpi-netconfig.conf
+[program:glpi-netconfig]
+command=/usr/bin/python3 /usr/share/glpi-agent/plugins/netconfig_backup.py
+directory=/usr/share/glpi-agent/plugins
+user=glpi-agent
+autostart=false
+autorestart=false
+startsecs=0
+stdout_logfile=/var/log/glpi_netconfig_supervisor.log
+stderr_logfile=/var/log/glpi_netconfig_supervisor_err.log
+environment=NETCONFIG_CONFIG="/etc/glpi-agent/netconfig_devices.yaml",GLPI_URL="https://glpi.example.com",NETCONFIG_AGENT_TOKEN="your_secure_token_here"
+```
+
+```bash
+# Comandi utili
+sudo supervisorctl reread
+sudo supervisorctl update
+sudo supervisorctl start glpi-netconfig
+sudo tail -f /var/log/glpi_netconfig_supervisor.log
+```
+
+### 🔸 Opzione C: Systemd Timer (consigliato per sistemi moderni)
+```ini
+# /etc/systemd/system/glpi-netconfig.service
+[Unit]
+Description=GLPI NetConfig Backup Task
+After=network.target
+
+[Service]
+Type=oneshot
+User=glpi-agent
+ExecStart=/usr/bin/python3 /usr/share/glpi-agent/plugins/netconfig_backup.py
+Environment="NETCONFIG_CONFIG=/etc/glpi-agent/netconfig_devices.yaml"
+Environment="GLPI_URL=https://glpi.example.com"
+Environment="NETCONFIG_AGENT_TOKEN=your_secure_token_here"
+Environment="SSL_VERIFY=true"
+StandardOutput=journal
+StandardError=journal
+```
+
+```ini
+# /etc/systemd/system/glpi-netconfig.timer
+[Unit]
+Description=Run GLPI NetConfig Backup every 6 hours
+Requires=glpi-netconfig.service
+
+[Timer]
+OnCalendar=*-*-* 02/6:00:00
+Persistent=true
+RandomizedDelaySec=300
+Unit=glpi-netconfig.service
+
+[Install]
+WantedBy=timers.target
+```
+
+```bash
+# Attivazione
+sudo systemctl daemon-reload
+sudo systemctl enable --now glpi-netconfig.timer
+
+# Verifica
+systemctl list-timers | grep netconfig
+journalctl -u glpi-netconfig.service -f
+```
+
+---
+
+## 🔌 6. Client API REST GLPI 11 (`src/Api/GlpiApiClient.php`)
+
+```php
+<?php
+declare(strict_types=1);
+
+namespace PluginNetconfig\Api;
+
+use GuzzleHttp\Client;
+use GuzzleHttp\Exception\RequestException;
+use GuzzleHttp\Exception\GuzzleException;
+
+/**
+ * Client per API REST GLPI 11
+ * Supporta App-Token + Session-Token o User-Token
+ * Gestisce automaticamente refresh sessione su 401
+ */
+class GlpiApiClient
+{
+    private string $baseUrl;
+    private string $appToken;
+    private ?string $sessionToken = null;
+    private Client $httpClient;
+
+    public function __construct(string $baseUrl, string $appToken, ?string $userToken = null)
+    {
+        $this->baseUrl = rtrim($baseUrl, '/');
+        $this->appToken = $appToken;
+        
+        $this->httpClient = new Client([
+            'base_uri' => $this->baseUrl . '/apirest.php/',
+            'timeout'  => 30.0,
+            'headers'  => [
+                'App-Token'    => $this->appToken,
+                'Content-Type' => 'application/json',
+                'Accept'       => 'application/json',
+            ],
+        ]);
+
+        if ($userToken) {
+            $this->loginWithUserToken($userToken);
+        }
+    }
+
+    /**
+     * Login con credenziali utente (username + password)
+     * @deprecated Usare loginWithUserToken per maggiore sicurezza
+     */
+    public function login(string $username, string $password): bool
+    {
+        try {
+            $response = $this->httpClient->post('initSession', [
+                'auth' => [$username, $password],
+                'http_errors' => true,
+            ]);
+            $data = json_decode($response->getBody(), true);
+            $this->sessionToken = $data['session_token'] ?? null;
+            return $this->sessionToken !== null;
+        } catch (RequestException $e) {
+            error_log("GLPI API login failed: " . $e->getMessage());
+            return false;
+        }
+    }
+
+    /**
+     * Login con user token (generato in Profilo > API, più sicuro)
+     */
+    public function loginWithUserToken(string $userToken): bool
+    {
+        try {
+            $response = $this->httpClient->post('initSession', [
+                'headers' => ['User-Token' => $userToken],
+                'http_errors' => true,
+            ]);
+            $data = json_decode($response->getBody(), true);
+            $this->sessionToken = $data['session_token'] ?? null;
+            return $this->sessionToken !== null;
+        } catch (RequestException $e) {
+            error_log("GLPI API user-token login failed: " . $e->getMessage());
+            return false;
+        }
+    }
+
+    /**
+     * Logout e distruzione sessione
+     */
+    public function logout(): void
+    {
+        if ($this->sessionToken) {
+            try {
+                $this->httpClient->delete('killSession', [
+                    'headers' => ['Session-Token' => $this->sessionToken],
+                    'http_errors' => false, // Ignora errori in logout
+                ]);
+            } catch (\Throwable $e) {
+                // Log silenzioso
+            }
+            $this->sessionToken = null;
+        }
+    }
+
+    /**
+     * Esegue una chiamata API con retry automatico su token scaduto
+     */
+    private function request(string $method, string $endpoint, array $data = [], bool $retry = true): ?array
+    {
+        $headers = $this->sessionToken ? ['Session-Token' => $this->sessionToken] : [];
+
+        try {
+            $response = $this->httpClient->request($method, $endpoint, [
+                'headers' => $headers,
+                'json'    => $data,
+                'http_errors' => true,
+            ]);
+            return json_decode($response->getBody(), true);
+        } catch (RequestException $e) {
+            // Se token scaduto (401) e retry abilitato, tenta re-login
+            if ($retry && $e->getResponse()?->getStatusCode() === 401 && $this->sessionToken) {
+                $this->logout();
+                // Tentativo di re-login con user token se disponibile
+                $userToken = getenv('GLPI_USER_TOKEN');
+                if ($userToken && $this->loginWithUserToken($userToken)) {
+                    return $this->request($method, $endpoint, $data, false); // retry una volta sola
+                }
+                throw new \RuntimeException("GLPI API session expired and re-authentication failed.");
+            }
+            throw $e;
+        }
+    }
+
+    /**
+     * Ottieni dispositivo di rete per ID
+     */
+    public function getNetworkEquipment(int $id): ?array
+    {
+        $result = $this->request('GET', "NetworkEquipment/$id");
+        return $result && !isset($result[0]['error']) ? $result : null;
+    }
+
+    /**
+     * Cerca dispositivi per nome/IP (per mapping agent -> GLPI ID)
+     */
+    public function searchNetworkEquipment(string $nameOrIp): array
+    {
+        $query = [
+            'criteria' => [
+                ['field' => 1, 'searchtype' => 'contains', 'value' => $nameOrIp], // name
+                ['OR' => [
+                    ['field' => 2, 'searchtype' => 'contains', 'value' => $nameOrIp], // ip
+                ]],
+            ],
+            'forcedisplay' => [1, 2, 3], // id, name, ip
+        ];
+
+        $result = $this->request('GET', 'search/NetworkEquipment', $query);
+        return $result['data'] ?? [];
+    }
+
+    /**
+     * Invia configurazione al plugin (endpoint personalizzato)
+     */
+    public function sendConfig(int $deviceId, string $config, string $agentToken): bool
+    {
+        $payload = [
+            'device_id' => $deviceId,
+            'config'    => $config,
+            'token'     => $agentToken,
+            'timestamp' => date('c'),
+        ];
+
+        $result = $this->request('POST', 'plugin/netconfig/agent', $payload);
+        return ($result['status'] ?? '') === 'ok';
+    }
+
+    /**
+     * Utility: ottieni lista dispositivi con ultima config
+     */
+    public function getDevicesWithLastConfig(): array
+    {
+        // Esempio: join tra NetworkEquipment e plugin_netconfig_configs
+        // Implementabile via search API o query diretta se necessario
+        return [];
+    }
+
+    public function __destruct()
+    {
+        $this->logout();
+    }
+}
+```
+
+---
+
+## 🚀 7. Installazione Passo-Passo
+
+### ✅ Prerequisiti
+- GLPI 11.0.6+ installato e funzionante
+- PHP 8.2+ con estensioni: `curl`, `json`, `mbstring`, `openssl`, `zip`
+- Composer 2.x installato globalmente
+- Accesso SSH al server GLPI e all'agent
+- MySQL/MariaDB con privilegi di creazione tabelle
+
+### 🔧 Procedura
+
+```bash
+# 1. Posiziona i file del plugin
+cd /var/www/glpi/plugins
+git clone <repo> netconfig
+# OPPURE copia manualmente i file nella struttura indicata
+
+# 2. Installa dipendenze Composer
+cd netconfig
+composer install --no-dev -o
+
+# 3. Imposta permessi corretti
+chown -R www-data:www-data /var/www/glpi/plugins/netconfig
+chmod -R 755 /var/www/glpi/plugins/netconfig
+
+# 4. Installa il plugin da UI GLPI
+#    Vai su: Configurazione > Plugin > Network Config Backup > Installa > Attiva
+
+# 5. Configura diritti profilo
+#    Amministrazione > Profili > [Seleziona profilo] > Tab "Network Configurations"
+#    Spunta: Read, Create, Update, Delete permanently come necessario
+
+# 6. Configura l'agent (su server separato o stesso host)
+#    - Copia netconfig_backup.py in /usr/share/glpi-agent/plugins/
+#    - Crea /etc/glpi-agent/netconfig_devices.yaml con i tuoi dispositivi
+#    - Imposta variabili d'ambiente in systemd/supervisor
+
+# 7. Testa manualmente l'agent
+sudo -u glpi-agent python3 /usr/share/glpi-agent/plugins/netconfig_backup.py
+
+# 8. Verifica in GLPI
+#    Apri un apparato: Rete > Apparati di rete > [Switch] > Tab "Config History"
+#    Dovresti vedere le configurazioni salvate con hash e data
+```
+
+### 🧪 Test Rapido con cURL
+```bash
+# Simula invio da agent (sostituisci valori reali)
+curl -X POST http://localhost/glpi/plugins/netconfig/ajax/agent_receive.php \
+  -H "Content-Type: application/json" \
+  -d '{
+    "device_id": 123,
+    "config": "!\nhostname TEST-SW\ninterface Vlan1\n ip address 10.0.0.1 255.255.255.0\nend",
+    "token": "your_agent_token_here"
+  }'
+
+# Risposta attesa:
+# {"status":"ok","message":"Configuration saved and versioned"}
+```
+
+---
+
+## ⚠️ 8. Risoluzione Problemi Composer
+
+### ❗ Il tuo output `composer diagnose`:
+```
+Checking composer.json: WARNING
+No license specified, it is recommended to do so. For closed-source software you may use "proprietary" as license.
+...
+Checking Composer and its dependencies for vulnerabilities: WARNING
+Could not find Composer's installed.json, this must be a non-standard Composer installation.
+```
+
+### ✅ Questi warning sono **NON bloccanti**:
+| Warning | Impatto | Soluzione |
+|---------|---------|-----------|
+| `No license specified` | Nessuno (solo informativo) | Aggiunto `"license": "GPL-3.0-or-later"` in `composer.json` |
+| `Could not find installed.json` | Nessuno se `composer install` funziona | Tipico in installazioni non-standard (es. GLPI in container). Ignorabile se il plugin si installa correttamente. |
+
+### 🔍 Se `symfony/diff` non viene trovato:
+```bash
+# 1. Aggiorna Composer
+composer self-update
+
+# 2. Pulisci cache
+composer clear-cache
+
+# 3. Verifica connessione a Packagist
+composer diagnose | grep packagist
+
+# 4. Forza reinstall con verbose
+composer install -vvv --no-dev -o
+
+# 5. Se ancora fallisce, specifica versione esplicita in composer.json:
+#    "symfony/diff": "6.4.3"
+```
+
+### 🐳 Se usi Docker/Container:
+```dockerfile
+# Assicurati che il volume composer cache sia montato correttamente
+# E che l'utente dentro il container abbia permessi di scrittura
+RUN composer install --no-dev -o --ignore-platform-reqs
+```
+
+---
+
+## 🔐 9. Sicurezza e Best Practice
+
+### ✅ Checklist Sicurezza
+- [ ] **Token agente**: Usa `openssl_rand_pseudo_bytes(32)` per generare `NETCONFIG_AGENT_TOKEN`
+- [ ] **Credenziali di rete**: Mai hardcodate. Usa:
+  - Variabili d'ambiente protette
+  - HashiCorp Vault / AWS Secrets Manager
+  - File con permessi `600` leggibili solo dall'utente agent
+- [ ] **Cifratura**: Il plugin usa `Glpi\Toolbox\Encryption` (AES-256-GCM). Verifica che `GLPI_CONFIG_DIR/config_db.php` contenga `crypt_key` valida.
+- [ ] **Export**: Il file `ajax/export.php` maschera automaticamente password/secret. Personalizza la regex in base alle tue policy.
+- [ ] **API REST**: Usa sempre `User-Token` invece di username/password. Genera token in *Amministrazione > Utenti > [Utente] > API*.
+- [ ] **Log**: Configura `log_level` in GLPI e ruota i log dell'agent (`logrotate`).
+
+### 🔐 Generazione Token Sicuri
+```bash
+# Token agente (32 byte hex)
+openssl rand -hex 32
+# Esempio output: a1b2c3d4e5f6...
+
+# User-Token GLPI (generato da UI, ma verificabile via CLI)
+php /var/www/glpi/bin/console glpi:api:token --user=backup_agent
+```
+
+### 🛡️ Hardening Agent Python
+```python
+# Aggiungi in netconfig_backup.py, prima di fetch_config():
+import secrets, sys
+
+# Verifica integrità script (opzionale, per ambienti ad alta sicurezza)
+EXPECTED_HASH = os.getenv('NETCONFIG_SCRIPT_HASH')
+if EXPECTED_HASH:
+    import hashlib
+    with open(__file__, 'rb') as f:
+        actual_hash = hashlib.sha256(f.read()).hexdigest()
+    if actual_hash != EXPECTED_HASH:
+        logger.critical("Script integrity check failed!")
+        sys.exit(1)
+```
+
+---
+
+## ✅ 10. Checklist Finale di Deploy
+
+| Step | Comando / Azione | Verifica |
+|------|-----------------|----------|
+| 1 | `composer install -o --no-dev` in `plugins/netconfig/` | ✅ Nessun errore, cartella `vendor/` presente |
+| 2 | Installa plugin da UI GLPI > Plugin | ✅ Stato: "Installato e attivato" |
+| 3 | Assegna diritti in *Amministrazione > Profili* | ✅ Tab `Network Configurations` visibile con permessi |
+| 4 | Copia script Python in `/usr/share/glpi-agent/plugins/` | ✅ `chmod +x`, proprietario `glpi-agent`, permessi `755` |
+| 5 | Configura `/etc/glpi-agent/netconfig_devices.yaml` | ✅ Permessi `600`, nessun dato sensibile in chiaro |
+| 6 | Imposta variabili d'ambiente in systemd/supervisor | ✅ `echo $NETCONFIG_AGENT_TOKEN` restituisce valore |
+| 7 | Testa manualmente: `sudo -u glpi-agent python3 netconfig_backup.py` | ✅ Log mostrano "Config saved" per dispositivi di test |
+| 8 | Attiva timer/scheduler | ✅ `systemctl list-timers` o `crontab -l` mostra job attivo |
+| 9 | Verifica in GLPI: apri un NetworkEquipment > tab *Config History* | ✅ Configurazioni appaiono con hash, data, utente |
+| 10 | Testa export e diff | ✅ Pulsante "Export" scarica file, diff evidenzia modifiche |
+| 11 | Testa massive action "Force backup now" | ✅ Triggera backup immediato per dispositivi selezionati |
+| 12 | Verifica cifratura DB | ✅ Campo `config_content` in DB è cifrato (non leggibile in chiaro) |
+
+---
+
+## 🆘 Supporto e Debug
+
+Se incontri problemi, fornisci:
+```bash
+# 1. Versioni esatte
+php /var/www/glpi/bin/console glpi:version
+composer --version
+python3 --version
+
+# 2. Log rilevanti
+tail -50 /var/log/glpi/php-errors.log
+tail -50 /var/log/glpi_agent_netconfig.log
+journalctl -u glpi-netconfig.service -n 50
+
+# 3. Output composer
+composer diagnose
+composer show symfony/diff
+
+# 4. Test endpoint API
+curl -v http://localhost/glpi/apirest.php/initSession -H "App-Token: YOUR_TOKEN"
+```
+
+---
+
+> 📌 **Nota Finale**: Questo plugin è progettato per GLPI 11.0.6+. Per aggiornamenti futuri di GLPI, verifica la compatibilità degli hook e delle API in [https://github.com/glpi-project/glpi/blob/11.0/CHANGELOG.md](https://github.com/glpi-project/glpi/blob/11.0/CHANGELOG.md).
+
+**Buon backup! 🔄🔐**
diff --git a/ajax/agent_receive.php b/ajax/agent_receive.php
new file mode 100644
index 0000000..e1c6b2d
--- /dev/null
+++ b/ajax/agent_receive.php
@@ -0,0 +1,11 @@
+<?php
+declare(strict_types=1);
+include('../../../inc/includes.php');
+
+header('Content-Type: application/json');
+Session::checkLoginUser();
+
+$input = json_decode(file_get_contents('php://input'), true);
+$handler = new \PluginNetconfig\Agent\Receive();
+echo json_encode($handler($input, 'POST', '/plugin/netconfig/agent'));
+exit;
diff --git a/for_glpi_agent/-usr-share-glpi_agent-plugins_/netconfig_backup.py b/for_glpi_agent/-usr-share-glpi_agent-plugins_/netconfig_backup.py
new file mode 100644
index 0000000..e128dce
--- /dev/null
+++ b/for_glpi_agent/-usr-share-glpi_agent-plugins_/netconfig_backup.py
@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+GLPI Agent Task: netconfig_backup
+Recupera configurazione da apparati di rete e invia a GLPI plugin netconfig
+Requisiti: netmiko, requests, pyyaml
+Install: pip3 install netmiko requests pyyaml
+"""
+
+import os
+import sys
+import json
+import hashlib
+import logging
+import requests
+from datetime import datetime
+from typing import Optional, Dict, List
+from netmiko import ConnectHandler, NetmikoTimeoutException, NetmikoAuthenticationException
+import yaml
+
+# Configurazione logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('/var/log/glpi_agent_netconfig.log'),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger('netconfig_backup')
+
+# Configurazione da file YAML esterno (sicuro, non hardcodato)
+CONFIG_FILE = os.getenv('NETCONFIG_CONFIG', '/etc/glpi-agent/netconfig_devices.yaml')
+GLPI_URL = os.getenv('GLPI_URL', 'http://localhost/glpi')
+GLPI_TOKEN = os.getenv('GLPI_APP_TOKEN', '')
+AGENT_TOKEN = os.getenv('NETCONFIG_AGENT_TOKEN', 'change_me_in_production')
+TIMEOUT = int(os.getenv('NETCONFIG_TIMEOUT', '30'))
+RETRIES = int(os.getenv('NETCONFIG_RETRIES', '2'))
+
+
+def load_devices_config(path: str) -> List[Dict]:
+    """Carica configurazione dispositivi da YAML"""
+    if not os.path.exists(path):
+        logger.error(f"Config file not found: {path}")
+        return []
+    
+    try:
+        with open(path, 'r') as f:
+            data = yaml.safe_load(f)
+        return data.get('devices', [])
+    except Exception as e:
+        logger.error(f"Error loading config: {e}")
+        return []
+
+
+def get_device_connection_params(device: Dict) -> Dict:
+    """Prepara parametri di connessione per netmiko"""
+    device_type_map = {
+        'cisco_ios': 'cisco_ios',
+        'cisco_nxos': 'cisco_nxos',
+        'hp_comware': 'hp_comware',
+        'juniper_junos': 'juniper_junos',
+        'arista_eos': 'arista_eos',
+        'paloalto_panos': 'paloalto_panos',
+    }
+    
+    return {
+        'device_type': device_type_map.get(device['platform'], 'cisco_ios'),
+        'host': device['ip'],
+        'username': device.get('username', os.getenv('NETCONFIG_DEFAULT_USER')),
+        'password': device.get('password', os.getenv('NETCONFIG_DEFAULT_PASS')),
+        'secret': device.get('enable_password', os.getenv('NETCONFIG_ENABLE_PASS')),
+        'port': device.get('port', 22),
+        'timeout': TIMEOUT,
+        'session_log': None,
+        'global_delay_factor': device.get('delay_factor', 1),
+    }
+
+
+def fetch_config(device: Dict) -> Optional[str]:
+    """Recupera configurazione via SSH con netmiko"""
+    params = get_device_connection_params(device)
+    
+    for attempt in range(RETRIES + 1):
+        try:
+            logger.info(f"Connecting to {device['name']} ({params['host']}) [attempt {attempt+1}]")
+            connection = ConnectHandler(**params)
+            
+            # Abilita modalità enable se necessaria
+            if params.get('secret'):
+                connection.enable()
+            
+            # Comando di show config (personalizzabile per piattaforma)
+            command = device.get('command', 'show running-config')
+            config = connection.send_command(command, expect_string=r'#|\$', max_loops=150)
+            
+            connection.disconnect()
+            
+            # Pulizia output da caratteri di controllo
+            config = config.strip()
+            config = '\n'.join(line.rstrip() for line in config.splitlines())
+            
+            logger.info(f"Config fetched successfully for {device['name']}")
+            return config
+            
+        except NetmikoAuthenticationException as e:
+            logger.error(f"Auth failed for {device['name']}: {e}")
+            break  # Non ritentare se auth fallisce
+        except NetmikoTimeoutException as e:
+            logger.warning(f"Timeout for {device['name']}: {e}")
+        except Exception as e:
+            logger.error(f"Unexpected error for {device['name']}: {e}")
+    
+    return None
+
+
+def send_to_glpi(device_id: int, config: str) -> bool:
+    """Invia configurazione a GLPI plugin endpoint"""
+    url = f"{GLPI_URL}/plugins/netconfig/ajax/agent_receive.php"
+    
+    payload = {
+        'device_id': device_id,
+        'config': config,
+        'token': AGENT_TOKEN,
+        'timestamp': datetime.utcnow().isoformat(),
+        'agent_version': '1.0.0'
+    }
+    
+    headers = {
+        'Content-Type': 'application/json',
+        'App-Token': GLPI_TOKEN,  # Opzionale: autenticazione API GLPI
+    }
+    
+    try:
+        response = requests.post(
+            url,
+            json=payload,
+            headers=headers,
+            timeout=30,
+            verify=os.getenv('SSL_VERIFY', 'true').lower() == 'true'
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            logger.info(f"GLPI response: {result.get('message', 'OK')}")
+            return result.get('status') == 'ok'
+        else:
+            logger.error(f"GLPI HTTP {response.status_code}: {response.text}")
+            return False
+            
+    except requests.RequestException as e:
+        logger.error(f"Request to GLPI failed: {e}")
+        return False
+
+
+def calculate_hash(config: str) -> str:
+    """Calcola SHA256 della configurazione"""
+    return hashlib.sha256(config.encode('utf-8')).hexdigest()
+
+
+def run_task():
+    """Entry point della task"""
+    logger.info("=== NetConfig Backup Task Started ===")
+    
+    devices = load_devices_config(CONFIG_FILE)
+    if not devices:
+        logger.warning("No devices configured, exiting")
+        return
+    
+    success_count = 0
+    for device in devices:
+        try:
+            device_name = device.get('name', 'unknown')
+            device_id = device.get('glpi_id')  # ID in glpi_networkdevices
+            
+            if not device_id:
+                logger.warning(f"Skipping {device_name}: missing glpi_id")
+                continue
+            
+            config = fetch_config(device)
+            if not config:
+                logger.warning(f"Failed to fetch config for {device_name}")
+                continue
+            
+            # Invia a GLPI solo se diverso dall'ultimo (controllo lato server, ma ottimizzazione client)
+            if send_to_glpi(device_id, config):
+                success_count += 1
+                logger.info(f"✓ {device_name} - Config saved")
+            else:
+                logger.error(f"✗ {device_name} - Failed to save to GLPI")
+                
+        except Exception as e:
+            logger.exception(f"Unhandled error for device {device.get('name')}")
+    
+    logger.info(f"=== Task Completed: {success_count}/{len(devices)} devices processed ===")
+
+
+if __name__ == '__main__':
+    run_task()
diff --git a/for_glpi_agent/_etc_glpi-agent/netconfig_devices.yaml b/for_glpi_agent/_etc_glpi-agent/netconfig_devices.yaml
new file mode 100644
index 0000000..8a3d129
--- /dev/null
+++ b/for_glpi_agent/_etc_glpi-agent/netconfig_devices.yaml
@@ -0,0 +1,25 @@
+devices:
+  - name: "SW-Core-01"
+    ip: "10.0.0.1"
+    platform: "cisco_ios"
+    glpi_id: 123  # ID in glpi_networkdevices
+    username: "backup_user"
+    # password: "xxx"  # Meglio usare variabili d'ambiente o vault
+    enable_password: "enable_secret"
+    command: "show running-config"
+    delay_factor: 2
+
+  - name: "SW-Access-05"
+    ip: "10.0.0.5"
+    platform: "hp_comware"
+    glpi_id: 124
+    username: "admin"
+    command: "display current-configuration"
+
+
+
+
+# 🔐 Best Practice: Non inserire password nel YAML. Usa:
+# Variabili d'ambiente: NETCONFIG_DEFAULT_PASS
+# Vault esterno (HashiCorp Vault, AWS Secrets Manager)
+# File con permessi 600 leggibile solo dall'utente dell'agent
diff --git a/for_glpi_agent/alternativa_php_agent/php_agent.php b/for_glpi_agent/alternativa_php_agent/php_agent.php
new file mode 100644
index 0000000..5c4453f
--- /dev/null
+++ b/for_glpi_agent/alternativa_php_agent/php_agent.php
@@ -0,0 +1,22 @@
+#!/usr/bin/env php
+<?php
+// /usr/share/glpi_agent/plugins/netconfig_backup.php
+require_once '/path/to/glpi/vendor/autoload.php';
+
+use PluginNetconfig\Api\GlpiApiClient;
+
+// Carica config da YAML/JSON
+$devices = yaml_parse_file('/etc/glpi-agent/netconfig_devices.yaml')['devices'] ?? [];
+
+$api = new GlpiApiClient(
+    baseUrl: getenv('GLPI_URL') ?: 'http://localhost/glpi',
+    appToken: getenv('GLPI_APP_TOKEN'),
+    userToken: getenv('GLPI_USER_TOKEN')  // Più sicuro di username/password
+);
+
+foreach ($devices as $device) {
+    $config = fetchConfigViaNetmikoPhp($device); // Funzione custom con phpseclib3
+    if ($config) {
+        $api->sendConfig($device['glpi_id'], $config, getenv('NETCONFIG_AGENT_TOKEN'));
+    }
+}
diff --git a/for_glpi_agent/cron_supervisor/comandi_utili b/for_glpi_agent/cron_supervisor/comandi_utili
new file mode 100644
index 0000000..25511c1
--- /dev/null
+++ b/for_glpi_agent/cron_supervisor/comandi_utili
@@ -0,0 +1,9 @@
+# Ricarica configurazione supervisor
+sudo supervisorctl reread
+sudo supervisorctl update
+
+# Esegui manualmente la task
+sudo supervisorctl start glpi-netconfig
+
+# Monitora log in tempo reale
+sudo tail -f /var/log/glpi_netconfig_supervisor.log
diff --git a/for_glpi_agent/cron_supervisor/consigliato - supervisor per controllo processi b/for_glpi_agent/cron_supervisor/consigliato - supervisor per controllo processi
new file mode 100644
index 0000000..f39df4a
--- /dev/null
+++ b/for_glpi_agent/cron_supervisor/consigliato - supervisor per controllo processi	
@@ -0,0 +1,11 @@
+# /etc/supervisor/conf.d/glpi-netconfig.conf
+[program:glpi-netconfig]
+command=/usr/bin/python3 /usr/share/glpi_agent/plugins/netconfig_backup.py
+directory=/usr/share/glpi_agent/plugins
+user=glpi-agent
+autostart=false  # Non partire all'avvio, esegui solo on-demand
+autorestart=false
+startsecs=0
+stdout_logfile=/var/log/glpi_netconfig_supervisor.log
+stderr_logfile=/var/log/glpi_netconfig_supervisor_err.log
+environment=NETCONFIG_CONFIG="/etc/glpi-agent/netconfig_devices.yaml",GLPI_URL="https://glpi.example.com",NETCONFIG_AGENT_TOKEN="your_secure_token"
diff --git a/for_glpi_agent/cron_supervisor/consigliato_opzione_c-system.d b/for_glpi_agent/cron_supervisor/consigliato_opzione_c-system.d
new file mode 100644
index 0000000..9f355ab
--- /dev/null
+++ b/for_glpi_agent/cron_supervisor/consigliato_opzione_c-system.d
@@ -0,0 +1,48 @@
+# /etc/systemd/system/glpi-netconfig.service
+[Unit]
+Description=GLPI NetConfig Backup Task
+After=network.target
+
+[Service]
+Type=oneshot
+User=glpi-agent
+ExecStart=/usr/bin/python3 /usr/share/glpi_agent/plugins/netconfig_backup.py
+Environment="NETCONFIG_CONFIG=/etc/glpi-agent/netconfig_devices.yaml"
+Environment="GLPI_URL=https://glpi.example.com"
+Environment="NETCONFIG_AGENT_TOKEN=your_secure_token"
+StandardOutput=journal
+StandardError=journal
+
+
+
+
+
+
+
+-    altro ini (bho)
+
+
+# /etc/systemd/system/glpi-netconfig.timer
+[Unit]
+Description=Run GLPI NetConfig Backup every 6 hours
+Requires=glpi-netconfig.service
+
+[Timer]
+OnCalendar=*-*-* 02/6:00:00
+Persistent=true
+RandomizedDelaySec=300
+
+[Install]
+WantedBy=timers.target
+
+
+---
+# attivazioen disattivazioen timer 
+
+# Attiva e avvia il timer
+sudo systemctl daemon-reload
+sudo systemctl enable --now glpi-netconfig.timer
+
+# Verifica stato
+systemctl list-timers | grep netconfig
+journalctl -u glpi-netconfig.service -f
diff --git a/for_glpi_agent/cron_supervisor/crontab.add b/for_glpi_agent/cron_supervisor/crontab.add
new file mode 100644
index 0000000..f5021ac
--- /dev/null
+++ b/for_glpi_agent/cron_supervisor/crontab.add
@@ -0,0 +1,3 @@
+# /etc/cron.d/glpi-netconfig
+# Esegui backup ogni 6 ore alle 02:00, 08:00, 14:00, 20:00
+0 2,8,14,20 * * * glpi-agent /usr/bin/python3 /usr/share/glpi_agent/plugins/netconfig_backup.py >> /var/log/glpi_netconfig_cron.log 2>&1
diff --git a/install/mysql/install.sql b/install/mysql/install.sql
new file mode 100644
index 0000000..5ccd672
--- /dev/null
+++ b/install/mysql/install.sql
@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS `glpi_plugin_netconfig_configs` (
+  `id` int unsigned NOT NULL AUTO_INCREMENT,
+  `networkdevices_id` int unsigned NOT NULL DEFAULT '0',
+  `config_content` mediumtext NOT NULL,
+  `config_hash` char(64) NOT NULL,
+  `is_encrypted` tinyint NOT NULL DEFAULT '1',
+  `created_at` datetime NOT NULL,
+  `users_id` int unsigned NOT NULL DEFAULT '0',
+  PRIMARY KEY (`id`),
+  KEY `networkdevices_id` (`networkdevices_id`),
+  KEY `created_at` (`created_at`),
+  KEY `config_hash` (`config_hash`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
diff --git a/src/Agent/Receive.php b/src/Agent/Receive.php
new file mode 100644
index 0000000..06a35c7
--- /dev/null
+++ b/src/Agent/Receive.php
@@ -0,0 +1,55 @@
+<?php
+declare(strict_types=1);
+
+namespace PluginNetconfig\Agent;
+
+use PluginNetconfig\Config;
+use Glpi\Toolbox\Encryption;
+
+class Receive
+{
+    public function __invoke(array $input, string $method, string $route): array
+    {
+        header('Content-Type: application/json');
+
+        if ($method !== 'POST') {
+            return ['status' => 'error', 'message' => 'Method not allowed'];
+        }
+
+        // Validazione payload
+        if (!isset($input['device_id'], $input['config'], $input['token'])) {
+            http_response_code(400);
+            return ['status' => 'error', 'message' => 'Missing required fields'];
+        }
+
+        // Validazione token (configurare in .env o config GLPI)
+        $validToken = $_ENV['NETCONFIG_AGENT_TOKEN'] ?? 'change_me_in_production';
+        if ($input['token'] !== $validToken) {
+            http_response_code(401);
+            return ['status' => 'error', 'message' => 'Unauthorized'];
+        }
+
+        $hash = hash('sha256', $input['config']);
+        $last = Config::getLastConfigByDevice((int)$input['device_id']);
+
+        if ($last && $last['config_hash'] === $hash) {
+            return ['status' => 'ok', 'message' => 'No changes detected'];
+        }
+
+        $config = new Config();
+        $data = [
+            'networkdevices_id' => (int)$input['device_id'],
+            'config_content'    => Encryption::encrypt($input['config']),
+            'config_hash'       => $hash,
+            'users_id'          => 0, // Agent/System
+            'is_encrypted'      => 1,
+        ];
+
+        if ($config->add($data) !== false) {
+            return ['status' => 'ok', 'message' => 'Configuration saved and versioned'];
+        }
+
+        http_response_code(500);
+        return ['status' => 'error', 'message' => 'Database insertion failed'];
+    }
+}
diff --git a/templates/config_tab.html.twig b/templates/config_tab.html.twig
new file mode 100644
index 0000000..50d459b
--- /dev/null
+++ b/templates/config_tab.html.twig
@@ -0,0 +1,37 @@
+<div class="card">
+  <div class="card-body">
+    <table class="tab_cadre_fixehov">
+      <thead>
+        <tr>
+          <th>{{ __('Date') }}</th>
+          <th>{{ __('Hash') }}</th>
+          <th>{{ __('User') }}</th>
+          <th>{{ __('Actions') }}</th>
+        </tr>
+      </thead>
+      <tbody>
+        {% for config in configs %}
+        <tr class="tab_bg_1">
+          <td>{{ config.created_at }}</td>
+          <td><code>{{ config.config_hash|slice(0, 16) }}...</code></td>
+          <td>{{ config.users_id|getUserName }}</td>
+          <td>
+            {% if can_export %}
+            <a href="{{ path('/plugins/netconfig/ajax/export.php') }}?id={{ config.id }}" class="btn btn-sm btn-outline-primary">
+              <i class="fas fa-download"></i> {{ __('Export') }}
+            </a>
+            {% endif %}
+            {% if config.diff_html is defined %}
+            <button class="btn btn-sm btn-outline-info" onclick="alert('Diff: {{ config.diff_html|escape }}')">
+              {{ __('View Diff') }}
+            </button>
+            {% endif %}
+          </td>
+        </tr>
+        {% else %}
+        <tr class="tab_bg_1"><td colspan="4" class="center">{{ __('No configuration saved yet') }}</td></tr>
+        {% endfor %}
+      </tbody>
+    </table>
+  </div>
+</div>