@haltera/cli 1.0.0 → 1.0.1

package/README.md

@@ -0,0 +1,58 @@
+[![npm version](https://img.shields.io/npm/v/@haltera/cli.svg)](https://www.npmjs.com/package/@haltera/cli)
+![License: UNLICENSED](https://img.shields.io/badge/License-UNLICENSED-yellow.svg)
+
+# @haltera/cli
+
+CLI ufficiale di Haltera per la gestione operativa del Match Station su Raspberry Pi.
+
+## Requisiti
+
+- Node.js >= 20
+- Raspberry Pi con accesso di rete configurato
+
+## Installazione
+```bash
+npm install -g @haltera/cli
+```
+
+## Configurazione
+
+Al primo avvio, inizializza la configurazione:
+```bash
+haltera config init --deviceToken <token>
+```
+
+Il file di configurazione viene salvato in `/etc/haltera/config.json`.
+
+Per leggere o modificare singole chiavi:
+```bash
+haltera config get 
+haltera config set  
+```
+
+## Comandi
+```bash
+haltera --help
+```
+
+| Comando | Descrizione |
+|---|---|
+| `haltera config init` | Avvia il wizard di configurazione |
+| `haltera config get <key>` | Legge un valore di configurazione |
+| `haltera config set <key> <value>` | Imposta un valore di configurazione |
+| `haltera wifi` | Gestisce la connessione WiFi |
+| `haltera update status` | Gestisce gli aggiornamenti dei servizi |
+
+## Percorsi
+
+| Percorso | Contenuto |
+|---|---|
+| `/etc/haltera/config.json` | Configurazione |
+
+---
+
+Haltera è un software di gestione gare per sport da combattimento. Per maggiori informazioni visita [haltera.it](https://haltera.it).
+
+## Licenza
+
+Tutti i diritti riservati — [Alberti Group](https://albertigroup.it)

package/dist/commands/config/getConfig.js

@@ -0,0 +1,28 @@
+import { Command } from "commander";
+import { CONFIG_SCHEMA } from "../../helpers/configSchema.js";
+import { loadConfig, saveConfig } from "../../helpers/config.js";
+export const getCommand = new Command('get')
+    .description("Legge un valore dalla config")
+    .argument('<key>', 'Chiave di configurazione')
+    .action((key) => {
+    try {
+        if (!CONFIG_SCHEMA[key]) {
+            console.error(`Chiave non consentita: "${key}"`);
+            process.exit(1);
+        }
+        const cfg = loadConfig();
+        const value = cfg[key];
+        const def = CONFIG_SCHEMA[key];
+        if (value === undefined || value === '') {
+            console.log(def.default);
+            cfg[key] = def.default;
+            saveConfig(cfg);
+        }
+        else {
+            console.log(value);
+        }
+    }
+    catch (err) {
+        console.log(err instanceof Error ? err.message : String(err));
+    }
+});

package/dist/commands/config/index.js

@@ -0,0 +1,13 @@
+import { Command } from "commander";
+import { getCommand } from "./getConfig.js";
+import { setCommand } from "./setConfig.js";
+import { listCommand } from "./listConfig.js";
+import { showCommand } from "./showConfig.js";
+import { initCommand } from "./initConfig.js";
+export const configCommand = new Command('config');
+configCommand.description('Initialize and manage the Match Station config file');
+configCommand.addCommand(getCommand);
+configCommand.addCommand(setCommand);
+configCommand.addCommand(listCommand);
+configCommand.addCommand(showCommand);
+configCommand.addCommand(initCommand);

package/dist/commands/config/initConfig.js

@@ -0,0 +1,37 @@
+import { Command } from "commander";
+import { loadConfig, promptParam, saveConfig } from "../../helpers/config.js";
+import { CONFIG_SCHEMA } from "../../helpers/configSchema.js";
+import { confirm } from '@inquirer/prompts';
+import { ExitPromptError } from '@inquirer/core';
+export const initCommand = new Command('init')
+    .description('Configurazione guidata interattiva')
+    .option('-d, --skipdefaults', 'Salta le voci con un valore di default', false)
+    .action(async () => {
+    try {
+        const config = loadConfig();
+        const updated = { ...config };
+        const options = initCommand.opts();
+        console.log('\n🔧  Haltera Match Station — Configurazione iniziale\n');
+        for (const [key, param] of Object.entries(CONFIG_SCHEMA)) {
+            if (!param.hidden || (options.skipdefaults && param.default != undefined)) {
+                const current = config[key];
+                updated[key] = await promptParam(param, current);
+            }
+        }
+        console.log('');
+        const confirmed = await confirm({ message: 'Salvare la configurazione?', default: true });
+        if (confirmed) {
+            saveConfig(updated);
+            console.log('\n✅  Configurazione salvata.\n');
+        }
+        else {
+            console.log('\n⚠️   Configurazione annullata.\n');
+        }
+    }
+    catch (err) {
+        if (err instanceof ExitPromptError)
+            console.log('\n⚠️   Configurazione annullata.');
+        else if (err instanceof Error)
+            console.log(err.message);
+    }
+});

package/dist/commands/config/listConfig.js

@@ -0,0 +1,10 @@
+import { Command } from "commander";
+import { CONFIG_SCHEMA } from "../../helpers/configSchema.js";
+export const listCommand = new Command('list')
+    .description('Elenca i parametri configurabili')
+    .action(() => {
+    console.log('\nParametri configurabili:\n');
+    for (const [key, def] of Object.entries(CONFIG_SCHEMA))
+        if (!def.hidden)
+            console.log(`  ${key.padEnd(38)} ${def.description}`);
+});

package/dist/commands/config/setConfig.js

@@ -0,0 +1,31 @@
+import { Command } from "commander";
+import { CONFIG_SCHEMA } from "../../helpers/configSchema.js";
+import { loadConfig, saveConfig } from "../../helpers/config.js";
+export const setCommand = new Command('set')
+    .description("Setta un valore nella config")
+    .argument('<key>', 'Chiave di configurazione')
+    .argument('<value>', 'Valore da assegnare alla chiave')
+    .action((key, value) => {
+    try {
+        const def = CONFIG_SCHEMA[key];
+        if (!def) {
+            console.error(`Chiave non consentita: "${key}"`);
+            console.info(`Chiavi disponibili:\n${Object.keys(CONFIG_SCHEMA).map(k => `  ${k}`).join('\n')}`);
+            process.exit(1);
+        }
+        if (def.validate) {
+            const result = def.validate(value);
+            if (result !== true) {
+                console.error(`Valore non valido per "${key}": ${result}`);
+                process.exit(1);
+            }
+        }
+        const cfg = loadConfig();
+        cfg[key] = value;
+        saveConfig(cfg);
+        console.log(`✓ ${key} = ${def.sensitive ? '***' : value}`);
+    }
+    catch (err) {
+        console.log(err instanceof Error ? err.message : String(err));
+    }
+});

package/dist/commands/config/showConfig.js

@@ -0,0 +1,20 @@
+import { Command } from "commander";
+import { loadConfig, redactConfig } from "../../helpers/config.js";
+export const showCommand = new Command('show')
+    .description('Mostra la config completa (oscura i valori sensitive)')
+    .option('--decrypt', 'Mostra le chiavi sensibili come testo')
+    .action(() => {
+    try {
+        const options = showCommand.opts();
+        const cfg = loadConfig();
+        if (options.decrypt) {
+            console.log(JSON.stringify(cfg, null, 2));
+        }
+        else {
+            console.log(JSON.stringify(redactConfig(cfg), null, 2));
+        }
+    }
+    catch (err) {
+        console.log(err instanceof Error ? err.message : String(err));
+    }
+});

package/dist/commands/index.js

@@ -0,0 +1,10 @@
+import { configCommand } from "./config/index.js";
+import { installCommand } from "./install.js";
+import { networkCommand } from "./network/index.js";
+import { updateCommand } from "./update/index.js";
+export const commands = [
+    configCommand,
+    networkCommand,
+    updateCommand,
+    installCommand
+];

package/dist/commands/install.js

@@ -0,0 +1,69 @@
+import { Command } from "commander";
+import { checkPrerequisites, createDirectoriesAndFiles, createSystemdService, installService } from "../helpers/install.js";
+import { loadConfig, saveConfig } from "../helpers/config.js";
+import { checkDeviceToken, getLatestRelease, saveVersions } from "../helpers/version.js";
+import { execSync } from "child_process";
+export const installCommand = new Command("install")
+    .description('Install tutti i servizi sul dispositivo')
+    .option('-d --deviceToken <token>', 'Token di identificazione del dispositivo')
+    .option('-t --gitlabToken <token>', 'Token di gitlab per il primo avvio')
+    .action(async (options) => {
+    try {
+        if (!options.deviceToken) {
+            console.error('--deviceToken è obbligatorio per l\'installazione');
+            process.exit(1);
+        }
+        console.log(options.deviceToken);
+        const cfg = loadConfig();
+        if (await checkDeviceToken(options.deviceToken)) {
+            cfg['auth.deviceToken'] = options.deviceToken;
+            saveConfig(cfg);
+        }
+        checkPrerequisites();
+        const token = cfg['auth.gitlabToken'] || options.gitlabToken;
+        const rawServices = cfg['services'];
+        const serviceDir = cfg['path.service'];
+        const tmpDir = cfg['path.tmp'];
+        const dbPath = cfg['database.path'];
+        const logPath = cfg['log.path'];
+        const versionsPath = cfg['path.versions'];
+        if (!token) {
+            //TODO: HANDLE THIS CASE
+            console.error('HANDLE THIS CASE');
+            process.exit(1);
+        }
+        if (!rawServices || !serviceDir || !tmpDir) {
+            console.error('Configurazione mancante. Esegui `haltera config init`');
+            process.exit(1);
+        }
+        const services = String(rawServices).trim().split(',');
+        createDirectoriesAndFiles([serviceDir, tmpDir], [dbPath, logPath, versionsPath]);
+        const versions = {};
+        for (const service of services) {
+            try {
+                const latest = await getLatestRelease(service, token);
+                if (!latest) {
+                    console.warn(`⚠ ${service}: nessuna release trovata, saltato`);
+                    continue;
+                }
+                await installService(service, latest, token, tmpDir, serviceDir);
+                createSystemdService(service, serviceDir);
+                versions[service] = latest;
+            }
+            catch (err) {
+                console.error(`✗ ${service}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            execSync('systemctl daemon-reload', { stdio: 'inherit' });
+            for (const service of Object.keys(versions)) {
+                execSync(`systemctl enable haltera-${service}`, { stdio: 'inherit' });
+                execSync(`systemctl start haltera-${service}`, { stdio: 'inherit' });
+                console.log(`✓ haltera-${service} avviato`);
+            }
+            saveVersions(versions);
+            console.log('\n✓ Installazione completata');
+        }
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+    }
+});

package/dist/commands/network/checkConfig.js

@@ -0,0 +1,36 @@
+import { Command } from "commander";
+import { loadConfig } from "../../helpers/config.js";
+import { checkConnectivity } from "../../helpers/network.js";
+export const checkCommand = new Command('check')
+    .description("Controlla lo stato della connessione")
+    .option('-r, --retries <n>', 'Numero di tentativi in caso di errore')
+    .option('-d, --delay <ms>', 'Attesa in ms tra un tentativo e il successivo')
+    .action(async (options) => {
+    try {
+        const cfg = loadConfig();
+        const r = Number.parseInt(options.retries);
+        const d = Number.parseInt(options.delay);
+        const retries = r || cfg['server.retryCount'];
+        const delay = d || cfg['server.retryDelay'];
+        if (!retries || !delay) {
+            console.error('Configurazione mancante. Esegui haltera config init o specifica --retries e --delay');
+            process.exit();
+        }
+        for (let attempt = 1; attempt <= retries; attempt++) {
+            if (attempt > 1) {
+                console.log(`Retry ${attempt}/${retries}...`);
+                await new Promise(r => setTimeout(r, delay));
+            }
+            const result = await checkConnectivity();
+            if (result.internet && result.syncServer) {
+                console.log('✓ Internet: OK');
+                console.log('✓ Sync server: OK');
+                process.exit(0);
+            }
+            console.error(`✗ ${result.error}`);
+        }
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+    }
+});

package/dist/commands/network/connectConfig.js

@@ -0,0 +1,29 @@
+import { Command } from "commander";
+import { loadConfig } from "../../helpers/config.js";
+import { execSync } from "child_process";
+export const connectCommand = new Command('connect')
+    .description('Connette a una rete WiFi')
+    .option('--ssid <ssid>', 'Nome della rete WiFi')
+    .option('--password <password>', 'Password della rete WiFi')
+    .action((options) => {
+    try {
+        const cfg = loadConfig();
+        const s = options.ssid;
+        const p = options.password;
+        const ssid = s || cfg['network.wifiSSID'];
+        const password = p || cfg['network.wifiPassword'];
+        if (!ssid) {
+            console.error('Configurazione mancante. Esegui haltera config init o specifica --ssid e --password');
+            process.exit();
+        }
+        if (password) {
+            execSync(`nmcli device wifi connect "${ssid}" password "${password}"`, { stdio: 'inherit' });
+        }
+        else {
+            execSync(`nmcli device wifi connect "${ssid}"`, { stdio: 'inherit' });
+        }
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+    }
+});

package/dist/commands/network/index.js

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import { checkCommand } from "./checkConfig.js";
+import { statusCommand } from "./statusConfig.js";
+import { connectCommand } from "./connectConfig.js";
+export const networkCommand = new Command('network');
+networkCommand.description('Manage raspberry connecctivity');
+networkCommand.addCommand(checkCommand);
+networkCommand.addCommand(statusCommand);
+networkCommand.addCommand(connectCommand);

package/dist/commands/network/statusConfig.js

@@ -0,0 +1,35 @@
+import { execSync } from "child_process";
+import { Command } from "commander";
+export const statusCommand = new Command('status')
+    .description('Mostra lo stato della connessione di rete')
+    .action(() => {
+    try {
+        requireNmcli();
+        const output = execSync('nmcli -t -f DEVICE,TYPE,STATE,CONNECTION device status', { encoding: 'utf-8' });
+        const lines = output.trim().split('\n');
+        for (const line of lines) {
+            const [device, type, state, connection] = line.split(':');
+            if (type === 'wifi' || type === 'ethernet') {
+                console.log(`Interfaccia : ${device}`);
+                console.log(`Tipo        : ${type}`);
+                console.log(`Stato       : ${state}`);
+                console.log(`Connessione : ${connection || '—'}`);
+                if (state === 'connected' && type === 'wifi') {
+                    const info = execSync(`nmcli -t -f SSID,SIGNAL,FREQ dev wifi list ifname ${device} --rescan no`, { encoding: 'utf-8' }).split('\n').find(l => l.trim());
+                    if (info) {
+                        const [ssid, signal, freq] = info.split(':');
+                        console.log(`SSID        : ${ssid}`);
+                        console.log(`Segnale     : ${signal}%`);
+                        console.log(`Frequenza   : ${freq}`);
+                    }
+                }
+                console.log();
+            }
+        }
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+    }
+});
+function requireNmcli() {
+}

package/dist/commands/update/applyConfig.js

@@ -0,0 +1,62 @@
+import { Command } from "commander";
+import { loadConfig } from "../../helpers/config.js";
+import { applyUpdate, downloadTarball, getLatestRelease, loadVersions, saveVersions } from "../../helpers/version.js";
+import { unlinkSync } from "fs";
+export const applyCommand = new Command('apply')
+    .description('Scarica e install gli aggiornamenti disponibili')
+    .option('--only <service...>', 'Aggiorna solo i servizi selezionati')
+    .action(async (options) => {
+    try {
+        const cfg = loadConfig();
+        const token = cfg['auth.gitlabToken'];
+        const tmpDir = cfg['path.tmp'];
+        const serviceDir = cfg['path.service'];
+        if (!token) {
+            //TODO: HANDLE THIS CASE
+            console.error('HANDLE THIS CASE');
+            process.exit(1);
+        }
+        if (!tmpDir || !serviceDir) {
+            console.error('Configurazione mancante. Esegui `haltera config init`');
+            process.exit(1);
+        }
+        const rawServices = cfg['services'];
+        if (!rawServices) {
+            console.error('Nessun servizio installabile');
+            process.exit(1);
+        }
+        const services = options.only ? options.only : String(rawServices).trim().split(',');
+        const versions = loadVersions();
+        for (const service of services) {
+            const current = versions[service];
+            if (!current) {
+                console.warn(`⚠ ${service}: versione locale non trovata`);
+                continue;
+            }
+            const latest = await getLatestRelease(service, token);
+            if (!latest) {
+                console.warn(`⚠ ${service}: nessuna release trovata su GitLab`);
+                continue;
+            }
+            if (current === latest) {
+                console.log(`✓ ${service}: aggiornato (${current})`);
+                continue;
+            }
+            console.log(`↑ ${service}: ${current ?? 'non installato'} → ${latest}`);
+            try {
+                const tarball = await downloadTarball(service, latest, token, tmpDir);
+                await applyUpdate(service, tarball, serviceDir);
+                versions[service] = latest;
+                saveVersions(versions);
+                unlinkSync(tarball);
+                console.log(`✓ ${service}: aggiornato a ${latest}`);
+            }
+            catch (err) {
+                console.error(`✗ ${service}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+    }
+});

package/dist/commands/update/checkConfig.js

@@ -0,0 +1,48 @@
+import { Command } from "commander";
+import { loadConfig } from "../../helpers/config.js";
+import { getLatestRelease, loadVersions } from "../../helpers/version.js";
+export const checkCommand = new Command("check")
+    .description('Controlla gli aggiornamenti disponibili per i servizi')
+    .option('--only <service...>', 'Nomi dei servizi da controllare')
+    .action(async (options) => {
+    try {
+        const cfg = loadConfig();
+        const token = cfg['auth.gitlabToken'];
+        const rawServices = cfg['services'];
+        if (!token) {
+            //TODO: HANDLE THIS CASE
+            console.error('HANDLE THIS CASE');
+            process.exit(1);
+        }
+        if (!rawServices) {
+            console.error('Nessun servizio installabile');
+            process.exit(1);
+        }
+        const versions = loadVersions();
+        let updatesAvailable = false;
+        const services = options.only ? options.only : String(rawServices).trim().split(',');
+        for (const service of services) {
+            const current = versions[service];
+            if (!current) {
+                console.warn(`⚠ ${service}: versione locale non trovata`);
+                continue;
+            }
+            const latest = await getLatestRelease(service, token);
+            if (!latest) {
+                console.warn(`⚠ ${service}: nessuna release trovata su GitLab`);
+                continue;
+            }
+            if (current === latest) {
+                console.log(`✓ ${service}: aggiornato (${current})`);
+            }
+            else {
+                console.log(`↑ ${service}: ${current} → ${latest}`);
+                updatesAvailable = true;
+            }
+        }
+        process.exit(updatesAvailable ? 1 : 0);
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+    }
+});

package/dist/commands/update/index.js

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import { checkCommand } from "./checkConfig.js";
+import { applyCommand } from "./applyConfig.js";
+import { statusCommand } from "./statusConfig.js";
+export const updateCommand = new Command('update');
+updateCommand.description("Manage service updates");
+updateCommand.addCommand(checkCommand);
+updateCommand.addCommand(applyCommand);
+updateCommand.addCommand(statusCommand);

package/dist/commands/update/statusConfig.js

@@ -0,0 +1,38 @@
+import { Command } from 'commander';
+import { loadConfig } from '../../helpers/config.js';
+import { compareVersions, loadVersions } from '../../helpers/version.js';
+import { getLatestRelease } from '../../helpers/version.js';
+export const statusCommand = new Command('status')
+    .description('Mostra lo stato degli aggiornamenti dei servizi')
+    .action(async () => {
+    try {
+        const cfg = loadConfig();
+        const token = cfg['auth.gitlabToken'];
+        const rawServices = cfg['services'];
+        if (!token) {
+            //TODO: HANDLE THIS CASE
+            console.error('HANDLE THIS CASE');
+            process.exit(1);
+        }
+        if (!rawServices) {
+            console.error('Nessun servizio installabile');
+            process.exit(1);
+        }
+        const services = String(rawServices).trim().split(',');
+        const versions = loadVersions();
+        for (const service of services) {
+            const current = versions[service] ?? 'non installato';
+            const latest = await getLatestRelease(service, token);
+            if (!latest) {
+                console.log(`${service}: locale=${current} | GitLab=non trovato`);
+                continue;
+            }
+            const cmp = compareVersions(current, latest);
+            const indicator = cmp === 0 ? '✓' : cmp > 0 ? '⚠' : '↑';
+            console.log(`${indicator} ${service}: locale=${current} | latest=${latest}`);
+        }
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+    }
+});

package/dist/helpers/config.js

@@ -0,0 +1,61 @@
+import fs from "fs";
+import path from "path";
+import { CONFIG_SCHEMA } from "./configSchema.js";
+import { confirm, input, password } from "@inquirer/prompts";
+const CONFIG_PATH = path.join('/etc', 'haltera', 'config.json');
+export function loadConfig() {
+    if (!fs.existsSync(CONFIG_PATH)) {
+        throw new Error(`Config non trovata in ${CONFIG_PATH}. Esegui prima: haltera config init`);
+    }
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+}
+export function saveConfig(config) {
+    if (!fs.existsSync(CONFIG_PATH)) {
+        fs.mkdirSync(CONFIG_PATH, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+export function redactConfig(obj) {
+    return Object.fromEntries(Object.entries(obj).map(([k, v]) => {
+        const fullKey = k;
+        return [k, CONFIG_SCHEMA[fullKey]?.sensitive ? '***' : v];
+    }));
+}
+export async function promptParam(param, currentValue) {
+    const hint = param.default ?? currentValue;
+    const message = `${param.description}:`;
+    switch (param.type) {
+        case 'boolean':
+            return confirm({
+                message,
+                default: hint ?? false
+            });
+        case 'number':
+            return input({
+                message,
+                default: hint,
+                validate: (v) => {
+                    if (isNaN(Number(v)))
+                        return 'Valore numerico richiesto';
+                    return param.validate ? param.validate(Number(v)) : true;
+                }
+            });
+        default:
+            if (param.sensitive) {
+                return password({
+                    message,
+                    mask: '*',
+                    validate: (v) => {
+                        if (!v)
+                            return true;
+                        return param.validate ? param.validate(v) : true;
+                    }
+                });
+            }
+            return input({
+                message,
+                default: hint,
+                validate: (v) => param.validate ? param.validate(v) : true,
+            });
+    }
+}

package/dist/helpers/configSchema.js

@@ -0,0 +1,152 @@
+export const CONFIG_SCHEMA = {
+    // STATION
+    'station.id': {
+        description: 'Identificatore univoco della station',
+        type: 'string',
+        validate: (v) => (typeof v === 'string' && v.length > 0) || 'Deve essere una stringa non vuota',
+    },
+    'station.name': {
+        description: 'Nome leggibile della stazione',
+        type: 'string',
+        validate: (v) => (typeof v === 'string' && v.length > 0) || 'Deve essere una stringa non vuota',
+    },
+    // AUTH
+    'auth.deviceToken': {
+        description: 'Token di autenticazione personal del raspberry',
+        type: 'string',
+        sensitive: true,
+        validate: (v) => (typeof v === 'string' && v.length > 0) || 'Deve essere una stringa non vuota',
+    },
+    'auth.gitlabToken': {
+        description: 'Token temporaneo di autenticazione per GitLab',
+        type: 'string',
+        sensitive: true,
+        hidden: true,
+        validate: (v) => (typeof v === 'string' && v.length > 0) || 'Deve essere una stringa non vuota',
+    },
+    // SERVER
+    'server.url': {
+        description: 'URL base del server centrale Haltera',
+        type: 'string',
+        validate: (v) => {
+            try {
+                const u = new URL(v);
+                return ['http:', 'https:'].includes(u.protocol) || 'Protocollo non valido (http/https)';
+            }
+            catch {
+                return 'URL non valido';
+            }
+        },
+    },
+    'server.retryCount': {
+        description: 'Numero di tentativi in caso di errore di comunicazione col server',
+        type: 'number',
+        default: 3,
+        validate: (v) => (Number.isInteger(v) && v >= 0) || 'Deve essere un intero >= 0',
+    },
+    'server.retryDelay': {
+        description: 'Millisecondi di attesa tra un tentativo e il successivo',
+        type: 'number',
+        default: 5000,
+        validate: (v) => (Number.isInteger(v) && v >= 0) || 'Deve essere un intero >= 0',
+    },
+    // DATABASE
+    'database.path': {
+        description: 'Percorso al file SQLite del Match Station',
+        type: 'string',
+        validate: (v) => (typeof v === 'string' && v.startsWith('/')) || 'Deve essere un percorso assoluto',
+    },
+    // SYNC
+    'sync.onStartup': {
+        description: 'Esegui una sincronizzazione immediata all\'avvio del service',
+        type: 'boolean',
+        default: true,
+        validate: (v) => typeof v === 'boolean' || 'Deve essere un booleano',
+    },
+    // PATHS
+    'path.service': {
+        description: 'Directory root di installazione dei service Haltera',
+        type: 'string',
+        validate: (v) => (typeof v === 'string' && v.startsWith('/')) || 'Deve essere un percorso assoluto',
+    },
+    'path.tmp': {
+        description: 'Directory temporanea per download tarball e file di aggiornamento',
+        type: 'string',
+        validate: (v) => (typeof v === 'string' && v.startsWith('/')) || 'Deve essere un percorso assoluto',
+    },
+    'path.versions': {
+        description: 'Percordo al file delle versone deii servizi',
+        type: 'string',
+        hidden: true,
+        validate: (v) => (typeof v === 'string' && v.startsWith('/')) || 'Deve essere un percorso assoluto',
+    },
+    // UPDATE
+    'update.auto': {
+        description: 'Scarica e applica automaticamente gli aggiornamenti disponibili all\'avvio',
+        type: 'boolean',
+        default: false,
+        validate: (v) => typeof v === 'boolean' || 'Deve essere un booleano',
+    },
+    'update.channel': {
+        description: 'Canale di aggiornamento da seguire (stable = produzione, beta = pre-release)',
+        type: 'string',
+        default: 'stable',
+        validate: (v) => ['stable', 'beta'].includes(v) || 'Valori accettati: stable, beta',
+    },
+    'update.restartServiceAfterUpdate': {
+        description: 'Riavvia automaticamente i service systemd dopo un aggiornamento completato',
+        type: 'boolean',
+        default: true,
+        validate: (v) => typeof v === 'boolean' || 'Deve essere un booleano',
+    },
+    // LOGGING
+    'log.level': {
+        description: 'Livello minimo di log da registrare (debug include tutti i livelli)',
+        type: 'string',
+        default: 'info',
+        validate: (v) => ['debug', 'info', 'warn', 'error'].includes(v) || 'Valori accettati: debug, info, warn, error',
+    },
+    'log.path': {
+        description: 'Percorso del file di log principale',
+        type: 'string',
+        validate: (v) => (typeof v === 'string' && v.startsWith('/')) || 'Deve essere un percorso assoluto',
+    },
+    // TIME & LOCALE
+    'timezone': {
+        description: 'Timezone del device per log e scheduling',
+        type: 'string',
+        validate: (v) => {
+            try {
+                new Intl.DateTimeFormat(undefined, { timeZone: v });
+                return true;
+            }
+            catch {
+                return 'Timezone non valida';
+            }
+        },
+    },
+    'locale': {
+        description: 'Locale per la formattazione di date e numeri',
+        type: 'string',
+        validate: (v) => /^[a-z]{2}-[A-Z]{2}$/.test(v) || 'Formato atteso: it-IT, en-US, ecc.',
+    },
+    // NETWORK
+    'network.wifiSSID': {
+        description: 'SSID della rete WiFi a cui connettersi automaticamente all\'avvio',
+        type: 'string',
+        validate: (v) => typeof v === 'string' || 'Deve essere una stringa',
+    },
+    'network.wifiPassword': {
+        description: 'Password della rete WiFi (usata da nmcli per la connessione automatica)',
+        type: 'string',
+        sensitive: true,
+        validate: (v) => typeof v === 'string' || 'Deve essere una stringa',
+    },
+    // SERVICES
+    'services': {
+        description: 'Nomi dei servizi, separati da una virgola',
+        type: "string",
+        hidden: true,
+        validate: (v) => typeof v === 'string' || 'Deve essere una stringa',
+    }
+};

package/dist/helpers/install.js

@@ -0,0 +1,70 @@
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "fs";
+import path from "path";
+export function checkPrerequisites() {
+    try {
+        execSync('which pnpm', { stdio: 'ignore' });
+    }
+    catch {
+        console.error('pnpm non trovato.');
+        execSync('npm install -g pnpm', { stdio: ['ignore', 'ignore', 'inherit'] });
+    }
+}
+export function createDirectoriesAndFiles(dirs = [], files = []) {
+    for (const dir of dirs) {
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+            console.log(`✓ Directory creata: ${dir}`);
+        }
+        else {
+            console.log(`✓ Directory già presente: ${dir}`);
+        }
+    }
+    for (const file of files) {
+        if (!existsSync(file)) {
+            mkdirSync(path.dirname(file), { recursive: true });
+            writeFileSync(file, '', { flag: 'wx' });
+            console.log(`✓ File creato: ${file}`);
+        }
+        else {
+            console.log(`✓ File già presente: ${file}`);
+        }
+    }
+}
+export async function installService(service, version, token, tmpDir, serviceDir) {
+    const url = `https://gitlab.com/api/v4/projects/haltera%2F${service}/packages/generic/${service}/${version}/${service}-v${version}.tgz`;
+    const tarball = path.join(tmpDir, `${service}-v${version}.tgz`);
+    console.log(`↓ Download ${service}@${version}...`);
+    const res = await fetch(url, { headers: { 'PRIVATE-TOKEN': token } });
+    if (!res.ok)
+        throw new Error(`Errore download ${service}: ${res.status}`);
+    const buffer = await res.arrayBuffer();
+    writeFileSync(tarball, Buffer.from(buffer));
+    const dest = path.join(serviceDir, service);
+    mkdirSync(dest, { recursive: true });
+    console.log(`📦 Estrazione ${service}...`);
+    execSync(`tar -xzf ${tarball} -C ${dest} --strip-components=1`);
+    console.log(`📦 Installazione dipendenze ${service}...`);
+    execSync(`cd ${dest} && pnpm install --frozen-lockfile`, { stdio: ['ignore', 'ignore', 'inherit'] });
+    unlinkSync(tarball);
+    console.log(`✓ ${service} installato`);
+}
+export function createSystemdService(service, serviceDir) {
+    const content = `[Unit]
+Description=Haltera ${service} service
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory=${path.join(serviceDir, service)}
+ExecStart=/usr/bin/node ${path.join(serviceDir, service, 'dist/index.js')}
+Restart=on-failure
+RestartSec=5s
+
+[Install]
+WantedBy=multi-user.target
+`;
+    const dest = `/etc/systemd/system/haltera-${service}.service`;
+    writeFileSync(dest, content, 'utf-8');
+    console.log(`✓ Service systemd creato: ${dest}`);
+}

package/dist/helpers/network.js

@@ -0,0 +1,34 @@
+import { execSync } from 'child_process';
+import { loadConfig } from './config.js';
+const DNS_CHECK_URL = 'https://1.1.1.1';
+export async function checkConnectivity() {
+    let internet = false;
+    try {
+        await fetch(DNS_CHECK_URL, { method: 'HEAD', signal: AbortSignal.timeout(3000) });
+        internet = true;
+    }
+    catch {
+        return { internet: false, syncServer: false, error: 'Nessuna connessione internet' };
+    }
+    let syncServer = false;
+    try {
+        const cfg = loadConfig();
+        const url = cfg['server.url'];
+        if (!url)
+            return { internet, syncServer: false, error: 'server.url non configurato' };
+        await fetch(`${url}/health`, { method: 'GET', signal: AbortSignal.timeout(5000) });
+        syncServer = true;
+    }
+    catch {
+        return { internet, syncServer: false, error: 'Sync server non raggiungibile' };
+    }
+    return { internet, syncServer };
+}
+export function requireNmcli() {
+    try {
+        execSync('which nmcli', { stdio: 'ignore' });
+    }
+    catch {
+        console.error('nmcli non trovato. Installa NetworkManager per usare i comandi di rete.');
+    }
+}

package/dist/helpers/version.js

@@ -0,0 +1,87 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { loadConfig } from "./config.js";
+import path from "path";
+import { execSync } from "child_process";
+export function loadVersions() {
+    try {
+        const cfg = loadConfig();
+        const versionPath = cfg['path.versions'];
+        if (versionPath && existsSync(versionPath)) {
+            return JSON.parse(readFileSync(versionPath, 'utf-8'));
+        }
+        else {
+            console.error('Services not found, run `haltera install` to install it');
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+    }
+}
+export function saveVersions(versions) {
+    try {
+        const cfg = loadConfig();
+        const versionPath = cfg['path.versions'];
+        if (versionPath && existsSync(versionPath)) {
+            writeFileSync(versionPath, JSON.stringify(versions, null, 2), 'utf-8');
+        }
+        else {
+            console.error('Services not found, run `haltera install` to install it');
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+    }
+}
+export async function getLatestRelease(service, token) {
+    const url = `https://gitlab.com/api/v4/projects/haltera%2F${service}/releases?per_page=1`;
+    const res = await fetch(url, {
+        headers: { 'PRIVATE-TOKEN': token }
+    });
+    if (!res.ok)
+        throw new Error(`Errore GitLab API per ${service}: ${res.status}`);
+    const releases = await res.json();
+    if (!releases.length)
+        return null;
+    const tag = releases[0].tag_name;
+    return tag.startsWith('v') ? tag.slice(1) : tag;
+}
+export async function downloadTarball(service, version, token, dir) {
+    const url = `https://gitlab.com/api/v4/projects/haltera%2F${service}/packages/generic/${service}/${version}/${service}-v${version}.tgz`;
+    const dest = path.join(dir, `${service}-v${version}.tgz`);
+    const res = await fetch(url, {
+        headers: { 'PRIVATE-TOKEN': token }
+    });
+    if (!res.ok)
+        throw new Error(`Errore download ${service}: ${res.status}`);
+    const buffer = await res.arrayBuffer();
+    writeFileSync(dest, Buffer.from(buffer));
+    return dest;
+}
+export async function applyUpdate(service, tarball, dir) {
+    const dest = path.join(dir, service);
+    mkdirSync(dest, { recursive: true });
+    execSync(`tar -xzf ${tarball} -C ${dest} --strip-components=1`, { stdio: 'inherit' });
+    execSync(`pnpm install --frozen-lockfile --prefix ${dest}`, { stdio: 'ignore' });
+    try {
+        execSync(`systemctl restart haltera-${service}`, { stdio: 'inherit' });
+    }
+    catch (err) {
+        console.error(`Error restarting the service, try restarting it manually with: \`systemctl restart haltera-${service}\``);
+    }
+}
+export function compareVersions(a, b) {
+    const pa = a.split('.').map(Number);
+    const pb = b.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if (pa[i] > pb[i])
+            return 1;
+        if (pa[i] < pb[i])
+            return -1;
+    }
+    return 0;
+}
+export async function checkDeviceToken(token) {
+    return true;
+}

package/dist/index.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import 'dotenv/config';
+import { commands } from './commands/index.js';
+function main() {
+    const program = new Command();
+    program.name('haltera').description('CLI per gestire Haltera su Raspberry').version("1.0.0");
+    commands.forEach(command => program.addCommand(command));
+    program.parse(process.argv);
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haltera/cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Handle haltera operativity via CLI",
   "type": "module",
   "main": "./dist/index.js",
@@ -14,9 +14,9 @@
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "tsc && chmod +x ./dist/index.js"
   },
-  "keywords": [ "haltera" ],
+  "keywords": [ "haltera", "albertigroup", "gym", "match software", "competitions" ],
   "author": "Alberti Group",
-  "license": "ISC",
+  "license": "UNLICENSED",
   "packageManager": "pnpm@10.33.0",
   "dependencies": {
     "@inquirer/core": "^11.1.7",