@noeva/analytics-core 0.1.0 → 0.3.0

package/contenuto/lib/snapshot/worker/installa.ps1

@@ -0,0 +1,340 @@
+# Installa o aggiorna il worker degli snapshot di {{progetto}} (NOEVA Analytics, ADR 0004),
+# passo per passo, e alla fine dice com'e' andata.
+#
+#   powershell -ExecutionPolicy Bypass -File .\installa.ps1                  installa o aggiorna
+#   powershell -ExecutionPolicy Bypass -File .\installa.ps1 -SoloControllo   controlla e basta (dopo un riavvio)
+#
+# Si lancia dalla cartella estratta dallo zip, ENTRANDO IN WINDOWS COME L'UTENTE CHE FARA'
+# GIRARE IL WORKER: le chiavi vanno nelle sue variabili d'ambiente. La copia in
+# C:\NOEVA\snapshot la fa lo script; se c'e' gia' e' un aggiornamento (la cartella vecchia si
+# mette da parte, lavoro\ e le chiavi restano). Alla fine il primo giro parte subito: lo
+# scheduler di NOEVA lo mette in coda e il worker lo esegue qui davanti, poi l'attivita'
+# pianificata prende il posto (ogni {{minuti}} minuti, ascolta --una-volta).
+# Nessun segreto finisce a schermo o nel file dell'esito.
+
+param([switch]$SoloControllo)
+
+$ErrorActionPreference = 'Stop'
+try { [Console]::OutputEncoding = [Text.Encoding]::UTF8 } catch { }
+
+$qui = Split-Path -Parent $MyInvocation.MyCommand.Path
+$progetto = '{{progetto}}'
+$utenteDb = '{{utente}}'
+$varPassword = '{{password_env}}'
+$dbHost = '{{host}}'
+$dbPorta = {{porta}}
+$minuti = {{minuti}}
+$pipeline = "analytics-snapshot-$progetto"
+$attivita = "NOEVA snapshot $progetto"
+$destinazione = 'C:\NOEVA\snapshot'
+$exe = Join-Path $destinazione 'noeva-snapshot\noeva-snapshot.exe'
+$pacchetto = Join-Path $destinazione "pacchetti\$progetto"
+$modo = 'nuova installazione'
+$esiti = New-Object System.Collections.ArrayList
+$conf = Get-Content (Join-Path $qui 'worker.json') -Raw -Encoding UTF8 | ConvertFrom-Json
+$api = $conf.api.TrimEnd('/')
+$contenitore = $conf.contenitore.TrimEnd('/')
+$workspace = $conf.workspace
+
+function Passo($titolo) {
+    Write-Host ''
+    Write-Host "== $titolo" -ForegroundColor Cyan
+}
+
+function Esito($passo, $stato, $nota) {
+    [void]$esiti.Add([pscustomobject]@{ Passo = $passo; Stato = $stato; Nota = $nota })
+    $colore = @{ 'ok' = 'Green'; 'avviso' = 'Yellow'; 'NO' = 'Red'; 'saltato' = 'DarkGray' }[$stato]
+    Write-Host ('  {0,-7} {1}' -f $stato, $nota) -ForegroundColor $colore
+}
+
+function Chiedi($domanda, [bool]$predefinito = $true) {
+    $suggerimento = if ($predefinito) { '(S/n)' } else { '(s/N)' }
+    $r = Read-Host "  $domanda $suggerimento"
+    if (-not $r) { return $predefinito }
+    return $r.Trim().ToLower().StartsWith('s')
+}
+
+function ChiediSegreto($domanda) {
+    $sicura = Read-Host "  $domanda" -AsSecureString
+    $bstr = [Runtime.InteropServices.Marshal]::SecureStringToBSTR($sicura)
+    try { return [Runtime.InteropServices.Marshal]::PtrToStringBSTR($bstr) }
+    finally { [Runtime.InteropServices.Marshal]::ZeroFreeBSTR($bstr) }
+}
+
+function PortaAperta($h, $p) {
+    $c = New-Object Net.Sockets.TcpClient
+    try { return $c.BeginConnect($h, $p, $null, $null).AsyncWaitHandle.WaitOne(5000) -and $c.Connected }
+    catch { return $false }
+    finally { $c.Close() }
+}
+
+function Esegui($comando, [string[]]$argomenti) {
+    $prima = $ErrorActionPreference
+    $ErrorActionPreference = 'Continue'
+    try {
+        $testo = (& $comando @argomenti 2>&1 | ForEach-Object { "$_" }) -join "`n"
+        return [pscustomobject]@{ Codice = $LASTEXITCODE; Testo = $testo }
+    } finally { $ErrorActionPreference = $prima }
+}
+
+# Come Esegui, ma le righe si vedono mentre arrivano (la verifica e il giro durano minuti).
+function EseguiDalVivo($comando, [string[]]$argomenti) {
+    $prima = $ErrorActionPreference
+    $ErrorActionPreference = 'Continue'
+    try {
+        $righe = New-Object System.Collections.ArrayList
+        & $comando @argomenti 2>&1 | ForEach-Object { $r = "$_"; [void]$righe.Add($r); Write-Host "    $r" }
+        return [pscustomobject]@{ Codice = $LASTEXITCODE; Testo = ($righe -join "`n") }
+    } finally { $ErrorActionPreference = $prima }
+}
+
+# Una chiamata all'API NOEVA con la chiave del worker. Cloudflare blocca lo user agent di
+# PowerShell come quello di Python: ci si presenta come noeva-snapshot.
+function ApiNoeva($metodo, $percorso, $corpo) {
+    $par = @{
+        Method = $metodo; Uri = "$api$percorso"; UseBasicParsing = $true; TimeoutSec = 60
+        UserAgent = 'noeva-snapshot (NOEVA Analytics)'
+        Headers = @{ Authorization = "Bearer $env:NOEVA_API_KEY"; 'x-noeva-workspace' = $workspace }
+    }
+    if ($corpo) { $par.Body = ($corpo | ConvertTo-Json -Compress); $par.ContentType = 'application/json' }
+    try {
+        $r = Invoke-WebRequest @par
+        return [pscustomobject]@{ Codice = [int]$r.StatusCode; Corpo = $(if ($r.Content) { $r.Content | ConvertFrom-Json } else { $null }); Errore = '' }
+    } catch {
+        $codice = 0
+        if ($_.Exception.Response) { $codice = [int]$_.Exception.Response.StatusCode }
+        $messaggio = if ($_.ErrorDetails -and $_.ErrorDetails.Message) { $_.ErrorDetails.Message } else { $_.Exception.Message }
+        return [pscustomobject]@{ Codice = $codice; Corpo = $null; Errore = $messaggio.Substring(0, [Math]::Min(200, $messaggio.Length)) }
+    }
+}
+
+function Fine {
+    $no = @($esiti | Where-Object { $_.Stato -eq 'NO' }).Count
+    $avvisi = @($esiti | Where-Object { $_.Stato -eq 'avviso' }).Count
+    $esitoGenerale = if ($no) { "NON COMPLETATA: $no passi da sistemare" } elseif ($avvisi) { "COMPLETATA con $avvisi avvisi" } else { 'COMPLETATA' }
+    $quando = Get-Date
+    $runner = ''
+    $quale = if (Test-Path $exe) { $exe } else { Join-Path $qui 'noeva-snapshot\noeva-snapshot.exe' }
+    if (Test-Path $quale) { try { $runner = ((Esegui $quale @('versione')).Testo | ConvertFrom-Json).runner } catch { } }
+    $righe = @(
+        "worker degli snapshot di $progetto (runner $runner) · $modo · $esitoGenerale",
+        "macchina $env:COMPUTERNAME · utente Windows $env:USERDOMAIN\$env:USERNAME · $($quando.ToString('dd/MM/yyyy HH:mm'))",
+        ''
+    ) + ($esiti | ForEach-Object { '{0,-7} {1,-20} {2}' -f $_.Stato, $_.Passo, $_.Nota })
+    Write-Host ''
+    Write-Host '==================== RIEPILOGO ====================' -ForegroundColor Cyan
+    $colore = if ($no) { 'Red' } elseif ($avvisi) { 'Yellow' } else { 'Green' }
+    Write-Host $righe[0] -ForegroundColor $colore
+    $righe | Select-Object -Skip 1 | ForEach-Object { Write-Host $_ }
+    $cartellaEsito = if (Test-Path $destinazione) { $destinazione } else { $qui }
+    $file = Join-Path $cartellaEsito ("esito-installa-{0}.txt" -f $quando.ToString('yyyyMMdd-HHmm'))
+    try {
+        $righe | Set-Content -Path $file -Encoding UTF8
+        Write-Host ''
+        Write-Host "Esito salvato in $file (senza chiavi ne' password): da mandare a chi segue l'installazione."
+    } catch { Write-Host "Non riesco a salvare l'esito in $file" -ForegroundColor Yellow }
+    if ($no) { exit 1 } else { exit 0 }
+}
+
+function Ferma($passo, $nota) {
+    Esito $passo 'NO' $nota
+    Write-Host '  Mi fermo qui: sistemato questo, rilancia lo script.' -ForegroundColor Red
+    Fine
+}
+
+Write-Host "NOEVA Analytics · worker degli snapshot di $progetto" -ForegroundColor Cyan
+Write-Host "macchina $env:COMPUTERNAME · utente Windows $env:USERDOMAIN\$env:USERNAME"
+if ($SoloControllo) { $modo = 'solo controllo'; Write-Host 'Solo controllo: non cambio niente.' }
+
+# 0. L'utente ----------------------------------------------------------------------
+if (-not $SoloControllo) {
+    Passo "0. L'utente Windows del worker"
+    Write-Host "  Il worker girera' come $env:USERDOMAIN\$env:USERNAME, con le sue variabili d'ambiente."
+    Write-Host '  Su un server: un account di servizio dedicato, non amministratore, non una persona.'
+    if (Chiedi "E' l'utente giusto?") { Esito 'utente' 'ok' "$env:USERDOMAIN\$env:USERNAME" }
+    else { Ferma 'utente' 'entra in Windows come l''utente del worker e rilancia' }
+}
+
+# 1. La rete -------------------------------------------------------------------------
+Passo '1. La rete: il database e NOEVA, solo in uscita'
+if (PortaAperta $dbHost $dbPorta) { Esito 'rete database' 'ok' "$dbHost`:$dbPorta" }
+else { Ferma 'rete database' "$dbHost`:$dbPorta non risponde: rete o VPN, per l'IT" }
+foreach ($u in @($api, $contenitore)) {
+    $h = ([Uri]$u).Host
+    if (PortaAperta $h 443) { Esito 'rete NOEVA' 'ok' "$h`:443" }
+    else { Ferma 'rete NOEVA' "$h`:443 non risponde: serve l'uscita HTTPS (proxy?), per l'IT" }
+}
+
+# 2. Il driver ODBC --------------------------------------------------------------------
+Passo '2. Il driver ODBC per SQL Server'
+$driver = @(Get-OdbcDriver -Platform 64-bit -ErrorAction SilentlyContinue | Where-Object { $_.Name -match '^ODBC Driver (18|17) for SQL Server$' } | ForEach-Object { $_.Name })
+if ($driver -contains 'ODBC Driver 18 for SQL Server') { Esito 'driver' 'ok' 'ODBC Driver 18 for SQL Server' }
+elseif ($driver -contains 'ODBC Driver 17 for SQL Server') {
+    if (-not $SoloControllo) { [Environment]::SetEnvironmentVariable('NOEVA_MSSQL_DRIVER', 'ODBC Driver 17 for SQL Server', 'User') }
+    $env:NOEVA_MSSQL_DRIVER = 'ODBC Driver 17 for SQL Server'
+    Esito 'driver' 'avviso' 'c''e'' il 17, non il 18: va bene, impostato NOEVA_MSSQL_DRIVER'
+} else {
+    Ferma 'driver' 'manca: ODBC Driver 18 for SQL Server x64 da https://aka.ms/downloadmsodbcsql (serve un amministratore)'
+}
+$driverUtente = [Environment]::GetEnvironmentVariable('NOEVA_MSSQL_DRIVER', 'User')
+if ($driverUtente) { $env:NOEVA_MSSQL_DRIVER = $driverUtente }
+
+# 3. La cartella -------------------------------------------------------------------------
+Passo "3. La cartella $destinazione"
+$giaInstallata = [bool](Get-ScheduledTask -TaskName $attivita -ErrorAction SilentlyContinue)
+if ($SoloControllo) {
+    if (Test-Path $exe) { Esito 'cartella' 'ok' $destinazione } else { Ferma 'cartella' "$exe non c'e'" }
+} elseif ($qui.TrimEnd('\') -ieq $destinazione) {
+    $modo = 'sul posto'
+    Esito 'cartella' 'ok' "lo script gira gia' da $destinazione"
+} else {
+    if (Test-Path $destinazione) {
+        $modo = 'aggiornamento'
+        # Durante la copia l'attivita' non deve partire: si riaccende al passo 7.
+        if ($giaInstallata) { Disable-ScheduledTask -TaskName $attivita | Out-Null }
+        $inCorso = @(Get-Process -Name 'noeva-snapshot' -ErrorAction SilentlyContinue)
+        if ($inCorso.Count) {
+            Write-Host '  Un giro e'' in corso: aspetto che finisca (al massimo 10 minuti).'
+            $inCorso | Wait-Process -Timeout 600 -ErrorAction SilentlyContinue
+        }
+        $vecchia = "$destinazione-prima-$((Get-Date).ToString('yyyyMMdd-HHmm'))"
+        try { Rename-Item $destinazione (Split-Path -Leaf $vecchia) }
+        catch { Ferma 'cartella' "non riesco a rinominare $destinazione (in uso?): $($_.Exception.Message)" }
+        Copy-Item $qui $destinazione -Recurse
+        # lavoro\ (gli ultimi giri e ascolta.log) resta: serve a capire i giri passati.
+        if (Test-Path (Join-Path $vecchia 'lavoro')) { Copy-Item (Join-Path $vecchia 'lavoro') (Join-Path $destinazione 'lavoro') -Recurse -Force }
+        Esito 'cartella' 'ok' "vecchia messa da parte in $vecchia, lavoro\ riportato"
+    } else {
+        New-Item -ItemType Directory -Force (Split-Path $destinazione) | Out-Null
+        Copy-Item $qui $destinazione -Recurse
+        Esito 'cartella' 'ok' "copiata in $destinazione"
+    }
+    Get-ChildItem $destinazione -Recurse | Unblock-File
+    if (-not (Test-Path $exe)) { Ferma 'cartella' "$exe non c'e' dopo la copia" }
+}
+New-Item -ItemType Directory -Force (Join-Path $destinazione 'lavoro') | Out-Null
+$v = Esegui $exe @('versione')
+if ($v.Codice -eq 0) { Esito 'eseguibile' 'ok' $v.Testo.Trim() } else { Ferma 'eseguibile' "non parte: $($v.Testo.Trim())" }
+
+# 4. La chiave del worker -----------------------------------------------------------------
+Passo '4. La chiave NOEVA del worker'
+$chiave = [Environment]::GetEnvironmentVariable('NOEVA_API_KEY', 'User')
+if ($chiave -and -not $SoloControllo -and -not (Chiedi "La chiave e' gia' salvata per $env:USERNAME. La tengo?")) { $chiave = '' }
+if (-not $chiave) {
+    if ($SoloControllo) { Ferma 'chiave' 'manca NOEVA_API_KEY: rilancia senza -SoloControllo' }
+    for ($i = 0; $i -lt 3; $i++) {
+        $chiave = ChiediSegreto "Chiave NOEVA dell'utente di servizio (noeva_sk_..., non si vede mentre scrivi)"
+        if ($chiave.StartsWith('noeva_sk_')) { break }
+        Write-Host '  Non sembra una chiave NOEVA (comincia con noeva_sk_).' -ForegroundColor Yellow
+        $chiave = ''
+    }
+    if (-not $chiave) { Ferma 'chiave' 'nessuna chiave valida inserita' }
+    [Environment]::SetEnvironmentVariable('NOEVA_API_KEY', $chiave, 'User')
+}
+$env:NOEVA_API_KEY = $chiave
+$chiave = $null
+# La prova della chiave: un biglietto per una versione di prova. Dice in una volta se la chiave
+# vale, se l'utente e' membro del workspace e se il workspace ha il modulo. Non scrive niente.
+$b = ApiNoeva 'POST' '/api/analytics/biglietto-dati' @{ progetto = $progetto; versione = 'prova-installazione'; da = $env:COMPUTERNAME }
+switch ($b.Codice) {
+    200 { Esito 'chiave' 'ok' "valida, l'utente e' membro del workspace e il modulo e' attivo" }
+    401 { Ferma 'chiave' 'non valida o revocata: rilancia e reinseriscila' }
+    403 { Ferma 'chiave' "rifiutata: $($b.Errore) (l'utente e' membro del workspace? il modulo e' abilitato?)" }
+    503 { Ferma 'chiave' "l'API non rilascia biglietti (manca ANALYTICS_SEGRETO_DATI): e' da NOEVA, non da qui" }
+    default { Ferma 'chiave' "risposta inattesa dall'API ($($b.Codice)): $($b.Errore)" }
+}
+
+# 5. La password e la verifica ----------------------------------------------------------------
+Passo "5. La password di $utenteDb e la verifica dal vivo"
+$password = [Environment]::GetEnvironmentVariable($varPassword, 'User')
+if ($password -and -not $SoloControllo -and -not (Chiedi "La password e' gia' salvata per $env:USERNAME. La tengo?")) { $password = '' }
+if (-not $password) {
+    if ($SoloControllo) { Ferma 'password' "manca $varPassword`: rilancia senza -SoloControllo" }
+    for ($i = 0; $i -lt 3 -and -not $password; $i++) { $password = ChiediSegreto "Password di $utenteDb (non si vede mentre scrivi)" }
+    if (-not $password) { Ferma 'password' 'nessuna password inserita' }
+    [Environment]::SetEnvironmentVariable($varPassword, $password, 'User')
+}
+Set-Item "env:$varPassword" $password
+$password = $null
+$v = EseguiDalVivo $exe @('verifica', '--pacchetto', $pacchetto, '--connessione', (Join-Path $pacchetto 'connessione.json'))
+$avvisiVerifica = @($v.Testo -split "`n" | Where-Object { $_ -match '^\s*avviso\s' }).Count
+if ($v.Codice -eq 0 -and $avvisiVerifica) { Esito 'verifica' 'avviso' "i controlli tornano, $avvisiVerifica avvisi entro la tolleranza (dati che l'ERP riscrive)" }
+elseif ($v.Codice -eq 0) { Esito 'verifica' 'ok' 'connessione e cifre di controllo tornano' }
+else {
+    $primoNo = ($v.Testo -split "`n" | Where-Object { $_ -match '^\s*NO\s' } | Select-Object -First 1)
+    Ferma 'verifica' $(if ($primoNo) { $primoNo.Trim() } else { "uscita $($v.Codice)" })
+}
+
+# 6. Il primo giro ------------------------------------------------------------------------------
+if ($SoloControllo) {
+    $log = Join-Path $destinazione 'lavoro\ascolta.log'
+    if (Test-Path $log) {
+        $ultima = Get-Content $log -Tail 40 | Where-Object { $_ -match 'pubblicata|FALLITO' } | Select-Object -Last 1
+        Esito 'ultimo giro' $(if ($ultima -match 'FALLITO') { 'NO' } elseif ($ultima) { 'ok' } else { 'avviso' }) $(if ($ultima) { $ultima.Trim() } else { 'nessun giro ancora in ascolta.log' })
+    } else { Esito 'ultimo giro' 'avviso' 'ascolta.log non c''e'' ancora' }
+} else {
+    Passo '6. Il primo giro, adesso'
+    if (Chiedi 'Faccio partire adesso il primo giro (circa 4 minuti)?') {
+        $jobs = ApiNoeva 'GET' '/api/scheduled-jobs' $null
+        $job = @($jobs.Corpo.data | Where-Object { $_.process_function -eq $pipeline }) | Select-Object -First 1
+        if (-not $job) {
+            Esito 'schedulazione' 'NO' "nessuna schedulazione '$pipeline' nel workspace: va creata nel pannello NOEVA (tipo ETL)"
+        } else {
+            Esito 'schedulazione' $(if ($job.enabled) { 'ok' } else { 'avviso' }) ("'{0}', {1} {2}{3}" -f $job.name, $job.cron_expression, $job.timezone, $(if ($job.enabled) { '' } else { ', DISATTIVATA: riattivala dal pannello' }))
+            $t = ApiNoeva 'POST' "/api/scheduled-jobs/$($job.id)/trigger" $null
+            if ($t.Codice -ne 200) { Esito 'primo giro' 'NO' "non riesco a farlo partire ($($t.Codice)): $($t.Errore)" }
+            else {
+                Write-Host '  In coda. Lo eseguo qui (i giri arretrati in coda, se ce ne sono, passano tutti):'
+                $g = EseguiDalVivo $exe @('ascolta', '--config', (Join-Path $destinazione 'worker.json'), '--una-volta')
+                Add-Content -Path (Join-Path $destinazione 'lavoro\ascolta.log') -Value $g.Testo -Encoding UTF8
+                $pubblicate = @([regex]::Matches($g.Testo, ': pubblicata (\S+) in') | ForEach-Object { $_.Groups[1].Value })
+                $falliti = @($g.Testo -split "`n" | Where-Object { $_ -match 'FALLITO' })
+                if ($falliti.Count) { Esito 'primo giro' 'NO' $falliti[0].Trim() }
+                elseif ($pubblicate.Count) { Esito 'primo giro' 'ok' "pubblicata la versione $($pubblicate[-1]) ($($pubblicate.Count) giri)" }
+                else { Esito 'primo giro' 'avviso' 'coda vuota: il giro lo prendera'' l''attivita'' pianificata, guarda ascolta.log' }
+            }
+        }
+    } else { Esito 'primo giro' 'saltato' 'lo fara'' l''attivita'' pianificata alla prossima schedulazione' }
+}
+
+# 7. L'attivita' pianificata --------------------------------------------------------------------
+Passo "7. L'attivita' pianificata '$attivita'"
+if ($SoloControllo) {
+    $t = Get-ScheduledTask -TaskName $attivita -ErrorAction SilentlyContinue
+    if (-not $t) { Esito 'attivita''' 'NO' 'non installata: rilancia senza -SoloControllo' }
+    else {
+        $info = Get-ScheduledTaskInfo -TaskName $attivita
+        $stato = if ($t.State -eq 'Disabled') { 'NO' } elseif ($info.LastTaskResult -in 0, 267009, 267011) { 'ok' } else { 'avviso' }
+        Esito 'attivita''' $stato ("{0}, ultimo avvio {1}, risultato {2}" -f $t.State, $info.LastRunTime, $info.LastTaskResult)
+    }
+} else {
+    Write-Host "  Ogni $minuti minuti lancia 'ascolta --una-volta' come $env:USERNAME, anche senza sessione aperta:"
+    Write-Host '  per questo Windows chiede la password di questo utente (quella di Windows, non del database).'
+    $credenziali = Get-Credential -UserName "$env:USERDOMAIN\$env:USERNAME" -Message "Password Windows di $env:USERNAME"
+    if (-not $credenziali) { Ferma 'attivita''' 'nessuna password Windows: senza, l''attivita'' non gira a sessione chiusa' }
+    $log = Join-Path $destinazione 'lavoro\ascolta.log'
+    $azione = New-ScheduledTaskAction -Execute 'cmd.exe' -WorkingDirectory $destinazione `
+        -Argument "/c `"`"$exe`" ascolta --config `"$(Join-Path $destinazione 'worker.json')`" --una-volta >> `"$log`" 2>&1`""
+    $quando = New-ScheduledTaskTrigger -Once -At (Get-Date).Date -RepetitionInterval (New-TimeSpan -Minutes $minuti)
+    $regole = New-ScheduledTaskSettingsSet -MultipleInstances IgnoreNew -ExecutionTimeLimit (New-TimeSpan -Hours 2) `
+        -StartWhenAvailable -DontStopIfGoingOnBatteries -AllowStartIfOnBatteries
+    try {
+        Register-ScheduledTask -TaskName $attivita -Action $azione -Trigger $quando -Settings $regole `
+            -User $credenziali.UserName -Password $credenziali.GetNetworkCredential().Password -RunLevel Limited -Force | Out-Null
+        Enable-ScheduledTask -TaskName $attivita | Out-Null
+        Esito 'attivita''' 'ok' "ogni $minuti minuti come $($credenziali.UserName); registro in $log"
+    } catch {
+        Esito 'attivita''' 'NO' "Windows l'ha rifiutata (password giusta?): $($_.Exception.Message)"
+    }
+    $credenziali = $null
+}
+
+# 8. La dashboard ------------------------------------------------------------------------------
+if (-not $SoloControllo) {
+    Passo '8. La dashboard'
+    Write-Host "  Apri $contenitore/$progetto/ (login NOEVA) e guarda la data dei dati."
+    if (Chiedi 'La data e'' quella di oggi?') { Esito 'dashboard' 'ok' 'dati di oggi' }
+    else { Esito 'dashboard' 'avviso' 'da guardare con chi segue l''installazione (la pagina si ricarica?)' }
+}
+
+Fine

package/core.js

@@ -50,7 +50,12 @@ export function leggiConfig(radice) {
   if (!Array.isArray(nonGestiti) || nonGestiti.some((p) => typeof p !== 'string')) {
     throw new ErroreConfig('analytics.json: `non_gestiti` deve essere un elenco di percorsi');
   }
-  return { progetto: c.progetto, nonGestiti };
+  // Il workspace NOEVA che possiede il progetto: lo nomina il biglietto con cui
+  // `analytics pubblica` scrive le pagine. Non e' un segreto, e' un id.
+  if (c.workspace !== undefined && typeof c.workspace !== 'string') {
+    throw new ErroreConfig('analytics.json: `workspace` deve essere l\'id del workspace NOEVA');
+  }
+  return { progetto: c.progetto, nonGestiti, ...(c.workspace ? { workspace: c.workspace } : {}) };
 }
 
 // --- file gestiti ---------------------------------------------------------
@@ -78,7 +83,9 @@ export function fileGestiti(config) {
   for (const f of readdirSync(join(CONTENUTO, 'assets')).sort()) {
     voci.push({ percorso: `apps/assets/${f}`, sorgente: join(CONTENUTO, 'assets', f) });
   }
-  voci.push({ percorso: '.github/workflows/ci.yml', sorgente: join(MODELLO, 'github', 'workflows', 'ci.yml') });
+  for (const w of ['ci.yml', 'rilascio-windows.yml']) {
+    voci.push({ percorso: `.github/workflows/${w}`, sorgente: join(MODELLO, 'github', 'workflows', w) });
+  }
   for (const nome of readdirSync(join(KIT, 'skills')).sort()) {
     const base = join(KIT, 'skills', nome);
     for (const f of fileSotto(base).sort()) {
@@ -269,6 +276,15 @@ export function verifica(radice, config) {
 
 // L'ultima versione pubblicata, o null se il registry non risponde o il pacchetto
 // non c'e': il controllo resta in sola lettura e non fallisce per la rete.
+/** a e' una versione piu' nuova di b? (x.y.z; un prerilascio o un formato strano non lo e') */
+export function piuNuova(a, b) {
+  const n = (v) => (/^\d+\.\d+\.\d+$/.test(v || '') ? v.split('.').map(Number) : null);
+  const [x, y] = [n(a), n(b)];
+  if (!x || !y) return false;
+  for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] > y[i];
+  return false;
+}
+
 export async function ultimaVersione(fetchImpl = fetch) {
   try {
     const r = await fetchImpl('https://registry.npmjs.org/@noeva%2fanalytics-core', { signal: AbortSignal.timeout(5000) });

package/modello/repository/github/workflows/ci.yml

@@ -1,7 +1,19 @@
-# La verifica del progetto: `analytics ci` del pacchetto @noeva/analytics-core.
-# Quali controlli girano lo decide la versione del pacchetto, non questo file:
-# qui ci sono solo l'installazione e il comando (ADR 0005 di NOEVA Analytics).
+# La verifica del progetto e, su main, la pubblicazione (ADR 0005 di NOEVA Analytics).
+# Quali controlli girano lo decide la versione del pacchetto @noeva/analytics-core,
+# non questo file: qui ci sono solo l'installazione e i comandi.
 # File gestito: lo riscrive `analytics upgrade`, non si modifica a mano.
+#
+# `pubblica` porta online, a ogni push su main che passa la verifica, le pagine
+# (apps/) e il modello compilato del commit: su R2, attraverso il contenitore, con
+# un biglietto che l'API NOEVA rilascia alla chiave di un membro del workspace del
+# progetto. Si accende con due impostazioni del repository:
+#
+#   secret   NOEVA_API_KEY         la chiave API NOEVA di un utente del workspace
+#   variable ANALYTICS_PUBBLICA    "si" quando il contenitore serve questo progetto da R2
+#   variable ANALYTICS_URL         facoltativa, default https://analytics.noeva.ai
+#
+# I dati no: lo snapshot si genera dove c'e' il database (aggiorna.sh --pubblica
+# sul Mac, o il worker dal cliente) e si pubblica da li'.
 
 name: ci
 
@@ -25,3 +37,41 @@ jobs:
           node-version: '24'
       - run: npm ci
       - run: npx analytics ci
+
+  pubblica:
+    needs: verifica
+    if: github.ref == 'refs/heads/main' && github.event_name != 'pull_request' && vars.ANALYTICS_PUBBLICA == 'si'
+    runs-on: ubuntu-latest
+    # Una pubblicazione alla volta, e quella in corso non si interrompe: la
+    # successiva aspetta e pubblica il main piu' recente.
+    concurrency:
+      group: pubblica
+      cancel-in-progress: false
+    env:
+      NOEVA_API_KEY: ${{ secrets.NOEVA_API_KEY }}
+      URL: ${{ vars.ANALYTICS_URL || 'https://analytics.noeva.ai' }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+      - run: npm ci
+      - name: la chiave API NOEVA c'e'
+        run: |
+          if [ -z "$NOEVA_API_KEY" ]; then
+            echo "::error::manca il secret NOEVA_API_KEY: la chiave di un utente del workspace del progetto"
+            exit 1
+          fi
+      - name: le pagine
+        run: npx analytics pubblica --url "$URL"
+      # Il modello si compila con wren, che e' Python: le versioni sono quelle del
+      # servizio locale (lib/mcp-locale/ambiente del pacchetto).
+      - uses: actions/setup-python@v5
+        if: hashFiles('wren_project.yml') != ''
+        with:
+          python-version: '3.11'
+      - name: il modello
+        if: hashFiles('wren_project.yml') != ''
+        run: |
+          pip install --quiet "wrenai==0.15.0" "wren-core-py==0.8.0" "pyyaml>=6"
+          PYTHON=python npx analytics modello --url "$URL"

package/modello/repository/github/workflows/rilascio-windows.yml

@@ -0,0 +1,207 @@
+# I due eseguibili Windows del progetto, costruiti e provati su un runner Windows
+# (PyInstaller non fa cross-compilazione), con le ricette del pacchetto
+# @noeva/analytics-core (ADR 0005 di NOEVA Analytics):
+#
+#   mcp        la cartella per Claude Code sui PC: noeva-<id>.exe, il servizio MCP,
+#              con la configurazione di consegna.yml. Il modello lo scarica da se'
+#              dall'ultima versione pubblicata (ci.yml, job pubblica); quello nella
+#              cartella e' l'ultimo ripiego.
+#   snapshot   l'eseguibile del worker degli snapshot (noeva-snapshot.exe) e il
+#              pacchetto del progetto, per il server del cliente (ADR 0004).
+#
+# Solo manuale. Nessuna credenziale: le cartelle non ne contengono, e il database
+# del cliente da qui non si raggiunge. Si prova fin dove si arriva senza: il driver
+# ODBC 18, il login che fallisce sulla rete, installa.ps1 con PowerShell 5.1.
+#
+# Le cartelle escono come artefatto (7 giorni). Con `rilascia` diventano una
+# versione permanente di questo repository: noeva-<id>-v<versione> e
+# noeva-snapshot-<id>-v<versione>. Una versione non si riscrive.
+# File gestito: lo riscrive `analytics upgrade`, non si modifica a mano.
+
+name: rilascio-windows
+
+on:
+  workflow_dispatch:
+    inputs:
+      cosa:
+        description: "mcp = la cartella per Claude Code sui PC; snapshot = l'eseguibile del worker (ADR 0004)"
+        type: choice
+        options: [mcp, snapshot]
+        default: mcp
+      versione:
+        description: "La versione (es. 2026.11.6); vuota = la data di oggi"
+        required: false
+        default: ""
+      rilascia:
+        description: "Pubblica la versione come release permanente di questo repository"
+        type: boolean
+        default: false
+
+permissions:
+  contents: write
+
+jobs:
+  windows:
+    runs-on: windows-latest
+    timeout-minutes: 40
+    env:
+      # Il builder e il server stampano accenti e "·": la console del runner no.
+      PYTHONUTF8: "1"
+      PYTHONIOENCODING: utf-8
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+      - run: npm ci
+      - uses: astral-sh/setup-uv@v6
+
+      - name: Il progetto e le ricette del pacchetto
+        id: dove
+        shell: pwsh
+        run: |
+          $id = (Get-Content analytics.json -Raw | ConvertFrom-Json).progetto
+          $lib = (npx analytics percorso) + "\lib"
+          $versione = "${{ inputs.versione }}"
+          if (-not $versione) { $d = Get-Date; $versione = "$($d.Year).$($d.Month).$($d.Day)" }
+          "id=$id" >> $env:GITHUB_OUTPUT
+          "lib=$lib" >> $env:GITHUB_OUTPUT
+          "versione=$versione" >> $env:GITHUB_OUTPUT
+          "progetto $id, versione $versione, ricette da $lib (@noeva/analytics-core $(npx analytics versione))"
+
+      - name: Il driver ODBC 18, come sui PC e sul server del cliente
+        shell: pwsh
+        run: |
+          choco install sqlserver-odbcdriver -y --no-progress | Out-Null
+          Get-OdbcDriver -Platform 64-bit | Select-Object Name
+
+      # --- mcp ------------------------------------------------------------------
+      - name: La cartella e l'eseguibile del servizio MCP
+        if: ${{ inputs.cosa == 'mcp' }}
+        shell: pwsh
+        run: uv run --with pyyaml python "${{ steps.dove.outputs.lib }}\mcp-locale\costruisci.py" . --versione "${{ steps.dove.outputs.versione }}"
+
+      # Il ramo vivo con il driver 18 e una password finta: deve dire "ok driver" e
+      # poi fallire sulla rete. Un errore di import o di driver vuol dire una ricetta
+      # PyInstaller da correggere.
+      - name: Il ramo vivo dell'eseguibile (pyodbc e driver 18, senza rete)
+        if: ${{ inputs.cosa == 'mcp' }}
+        shell: pwsh
+        run: |
+          $id = "${{ steps.dove.outputs.id }}"
+          $exe = "dist\mcp-locale\noeva-$id\noeva\noeva-$id.exe"
+          $conf = Get-Content "dist\mcp-locale\noeva-$id\noeva\noeva.json" -Raw | ConvertFrom-Json
+          $vive = $conf.sorgenti.PSObject.Properties | Where-Object { $_.Value.tipo -eq 'mssql' }
+          if (-not $vive) { "nessuna sorgente viva: niente da provare"; exit 0 }
+          foreach ($v in $vive) {
+            if ($v.Value.password_env) { [Environment]::SetEnvironmentVariable($v.Value.password_env, 'non-e-la-password', 'Process') }
+            $out = "$env:RUNNER_TEMP\verifica-$($v.Name).txt"
+            $p = Start-Process $exe -ArgumentList '--verifica', '--sorgente', $v.Name -NoNewWindow -PassThru -RedirectStandardOutput $out
+            $tempo = [Diagnostics.Stopwatch]::StartNew()
+            if (-not $p.WaitForExit(180000)) { $p.Kill(); "  (fermato dopo 180 s)" }
+            $testo = Get-Content $out -Raw
+            $testo
+            "  durata: $([int]$tempo.Elapsed.TotalSeconds) s"
+            if ($testo -match 'pyodbc non utilizzabile|non e'' installato') { throw "il ramo vivo non arriva al login: ricetta da correggere" }
+            if ($testo -notmatch 'ok  driver') { throw "nessun 'ok driver' per $($v.Name)" }
+          }
+          exit 0
+
+      - name: installa.ps1 parte e chiude con il riepilogo
+        if: ${{ inputs.cosa == 'mcp' }}
+        shell: pwsh
+        run: |
+          $dir = "dist\mcp-locale\noeva-${{ steps.dove.outputs.id }}"
+          $out = (powershell -NoProfile -ExecutionPolicy Bypass -File "$dir\installa.ps1" -SoloControllo 2>&1 | Out-String)
+          $out
+          if ($out -notmatch 'RIEPILOGO' -or $out -notmatch 'NON COMPLETATA') { throw "installa.ps1 non arriva al riepilogo" }
+          $esito = Get-ChildItem $dir -Filter 'esito-installa-*.txt'
+          if (-not $esito) { throw "installa.ps1 non scrive il file dell'esito" }
+          Remove-Item $esito.FullName
+          "ok: installa.ps1 gira con PowerShell 5.1 e chiude con l'esito"
+          exit 0
+
+      # --- snapshot -------------------------------------------------------------
+      - name: L'eseguibile degli snapshot e il pacchetto del progetto
+        if: ${{ inputs.cosa == 'snapshot' }}
+        shell: pwsh
+        run: |
+          uv run --with pyyaml python "${{ steps.dove.outputs.lib }}\snapshot\impacchetta.py" eseguibile .
+          uv run --with pyyaml python "${{ steps.dove.outputs.lib }}\snapshot\impacchetta.py" pacchetto .
+
+      - name: Prova dell'eseguibile fino al login
+        if: ${{ inputs.cosa == 'snapshot' }}
+        shell: pwsh
+        run: |
+          $id = "${{ steps.dove.outputs.id }}"
+          $exe = "dist\snapshot\noeva-snapshot\noeva-snapshot.exe"
+          $pac = "dist\snapshot\pacchetti\$id"
+          & $exe versione
+          if ($LASTEXITCODE -ne 0) { throw "versione: uscita $LASTEXITCODE" }
+          $conf = Get-Content "$pac\connessione.json" -Raw | ConvertFrom-Json
+          if ($conf.password_env) { [Environment]::SetEnvironmentVariable($conf.password_env, 'non-e-la-password', 'Process') }
+          $out = "$env:RUNNER_TEMP\verifica.txt"
+          $p = Start-Process $exe -ArgumentList 'verifica', '--pacchetto', $pac, '--connessione', "$pac\connessione.json" -NoNewWindow -PassThru -RedirectStandardOutput $out -RedirectStandardError "$out.err"
+          if (-not $p.WaitForExit(240000)) { $p.Kill(); "  (fermato dopo 240 s)" }
+          $testo = (Get-Content $out -Raw -Encoding utf8) + (Get-Content "$out.err" -Raw -Encoding utf8)
+          $testo
+          if ($testo -match 'ModuleNotFoundError|ImportError|No module named|non e'' installato|Data source name not found|manca la password') { throw "l'eseguibile non arriva al login: ricetta da correggere" }
+          if ($testo -notmatch 'TCP Provider|Login timeout|timeout|08001|HYT00|network') { throw "atteso un errore di rete al login, non trovato" }
+          "ok: l'eseguibile arriva al login, si ferma sulla rete come deve"
+          # ascolta (ADR 0004): con un'API che non risponde deve dirlo e uscire con 1.
+          $w = Get-Content dist\snapshot\worker.json -Raw | ConvertFrom-Json
+          $w.api = 'http://127.0.0.1:9'
+          $w | ConvertTo-Json -Depth 5 | Set-Content "$env:RUNNER_TEMP\worker.json" -Encoding utf8
+          Copy-Item dist\snapshot\pacchetti "$env:RUNNER_TEMP\pacchetti" -Recurse -Force
+          $env:NOEVA_API_KEY = 'noeva_sk_finta'
+          $testo = (& $exe ascolta --config "$env:RUNNER_TEMP\worker.json" --una-volta 2>&1 | Out-String)
+          $testo
+          if ($testo -notmatch "in ascolto per analytics-snapshot-$id" -or $testo -notmatch 'non riesco a chiedere lavoro') { throw "ascolta non parte come deve" }
+          $out = (powershell -NoProfile -ExecutionPolicy Bypass -File dist\snapshot\installa.ps1 -SoloControllo 2>&1 | Out-String)
+          $out
+          if ($out -notmatch 'RIEPILOGO' -or $out -notmatch 'NON COMPLETATA') { throw "installa.ps1 non arriva al riepilogo" }
+          Get-ChildItem dist\snapshot -Filter 'esito-installa-*.txt' | Remove-Item
+          exit 0
+
+      - name: Lo zip degli snapshot
+        if: ${{ inputs.cosa == 'snapshot' }}
+        shell: pwsh
+        run: Compress-Archive -Path dist\snapshot\noeva-snapshot, dist\snapshot\pacchetti, dist\snapshot\worker.json, dist\snapshot\*.ps1 -DestinationPath dist\snapshot\noeva-snapshot-windows.zip
+
+      # --- artefatto e versione permanente --------------------------------------
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ inputs.cosa }}-${{ steps.dove.outputs.versione }}
+          path: |
+            dist/mcp-locale/*.zip
+            dist/snapshot/noeva-snapshot-windows.zip
+          retention-days: 7
+
+      - name: La versione permanente (release)
+        if: ${{ inputs.rilascia }}
+        shell: pwsh
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          $id = "${{ steps.dove.outputs.id }}"
+          $versione = "${{ steps.dove.outputs.versione }}"
+          if ("${{ inputs.cosa }}" -eq "mcp") {
+            $tag = "noeva-$id-v$versione"; $titolo = "noeva-$id $versione"
+            $zip = "dist\mcp-locale\noeva-$id-$versione.zip"; Copy-Item "dist\mcp-locale\noeva-$id.zip" $zip
+            $guida = "docs\installazione-$id-windows.md"
+            $note = "Cartella per Claude Code su Windows: noeva-$id.exe, dal commit $env:GITHUB_SHA. Il modello arriva da solo dall'ultima versione pubblicata. Installazione: $guida (allegata); poi ``noeva\noeva-$id.exe --verifica``."
+            $latest = "--latest"
+          } else {
+            $tag = "noeva-snapshot-$id-v$versione"; $titolo = "noeva-snapshot $id $versione"
+            $zip = "dist\snapshot\noeva-snapshot-$id-windows-$versione.zip"; Copy-Item dist\snapshot\noeva-snapshot-windows.zip $zip
+            $guida = "docs\installazione-snapshot-$id-windows.md"
+            $note = "noeva-snapshot.exe per Windows e il pacchetto di $id (snapshot.yml, mdl.json, connessione.json senza password), dal commit $env:GITHUB_SHA. ADR 0004. Installazione: $guida (allegata)."
+            # la release in evidenza resta quella della cartella MCP che il cliente usa
+            $latest = "--latest=false"
+          }
+          gh release view $tag 2>$null
+          if ($LASTEXITCODE -eq 0) { throw "la versione $tag esiste gia': una versione non si riscrive, scegline un'altra" }
+          $file = @($zip)
+          if (Test-Path $guida) { $file += $guida }
+          gh release create $tag @file --target $env:GITHUB_SHA --title $titolo --notes $note $latest
+          "pubblicata $tag"