fantasta 0.2.0 → 0.3.0

package/README.md

@@ -1,35 +1,47 @@
 # Fantasta — avvia l'asta dal terminale
 
-Asta di Fantacalcio giocata in **LAN senza server**. Questo comando avvia la
-regia sul tuo computer; i partecipanti si collegano dal telefono (o da qualunque
-browser) sulla tua rete locale, senza installare nulla.
-
-Niente `npm install`: servi e via.
+Asta di Fantacalcio giocata in **LAN senza server**. Questo comando apre la
+**vera app desktop** sul tuo computer; i partecipanti si collegano dal telefono
+(o da qualunque browser) sulla tua rete locale, senza installare nulla.
 
 ```bash
 npx fantasta
 ```
 
+Niente installer, niente avvisi di sicurezza: il binario Electron incluso nel
+pacchetto è firmato da GitHub, quindi non c'è Gatekeeper da aggirare.
+
 ## Cosa succede
 
-- Si avvia il **server SQLite/LAN** locale (porta `47821`);
-- si avvia il **renderer** della regia (porta `47822`);
-- si apre il **browser** di default sulla home dell'asta;
+- Si apre la **finestra dell'app desktop** (regia);
+- si avvia il **server SQLite/LAN** locale (porta `47821`);
+- si avvia il **renderer** della regia (porta `47822`), raggiungibile anche dal
+  browser dei partecipanti;
 - **il terminale resta attivo** mentre l'asta è in corso: chiudilo con `Ctrl+C`
-  per fermare tutto e disconnettere i partecipanti.
+  per fermare tutto e disconnettere i partecipanti (oppure chiudi la finestra).
 
 I partecipanti si collegano con il **QR code** mostrato durante la creazione
 della lega (o col link) e seguono l'asta dal telefono. Serve una sola
 connessione: quella del PC che gestisce l'asta.
 
+## Modalità browser (opzionale)
+
+Se preferisci la regia nel browser di default invece della finestra:
+
+```bash
+npx fantasta --browser
+```
+
 ## Requisiti
 
 - **Node.js 22 o superiore** (il database usa `node:sqlite`, incluso nel runtime).
+- Al primo avvio npm scarica anche il binario Electron (~120 MB, una volta sola).
 
 ## Dove vengono salvati i dati
 
-- Database: `~/.fantasta/fantasta.db`
-- Sessione admin: `~/.fantasta/admin-session.txt`
+- Finestra desktop: `~/Library/Application Support/Fantasta/fantasta.db` (macOS),
+  `%APPDATA%/Fantasta/fantasta.db` (Windows), `~/.config/Fantasta/fantasta.db` (Linux).
+- Modalità browser / sessioni: `~/.fantasta/` (`fantasta.db`, `admin-session.txt`).
 
 ## Opzioni (variabili d'ambiente)
 
@@ -39,9 +51,9 @@ Tutte opzionali, se non impostate valgono i default qui sotto.
 | --- | --- | --- |
 | `FANTASTA_PORT` | `47821` | Porta del server locale (SQLite/LAN) |
 | `FANTASTA_RENDERER_PORT` | `47822` | Porta del renderer (regia e partecipanti) |
-| `FANTASTA_DATABASE_PATH` | `~/.fantasta/fantasta.db` | Percorso del database |
-| `FANTASTA_DATA_DIR` | `~/.fantasta` | Cartella dei dati (se il DB non è personalizzato) |
-| `FANTASTA_SESSION_FILE` | `~/.fantasta/admin-session.txt` | File della sessione admin |
+| `FANTASTA_DATABASE_PATH` | vedi sopra | Percorso del database |
+| `FANTASTA_DATA_DIR` | `~/.fantasta` | Cartella dei dati (modalità browser) |
+| `FANTASTA_BROWSER` | — | `1` equivale a `--browser` |
 
 Esempio con porte diverse:
 
@@ -49,15 +61,15 @@ Esempio con porte diverse:
 FANTASTA_PORT=49001 FANTASTA_RENDERER_PORT=49002 npx fantasta
 ```
 
-## Perché non c'è un installer?
-
-L'"app desktop" di Fantasta è in realtà **due processi Node**: il server LAN e
-il renderer. `npx` li avvia direttamente, senza `electron`, senza `.app` e senza
-binari nativi da firmare — per questo non c'è alcun **avviso di sicurezza**
-all'apertura su macOS, Windows o Linux (niente Gatekeeper da aggirare).
+## Perché npx e non l'installer?
 
-Se preferisci una finestra dedicata, la distribuzione installer (`.dmg`/`.exe`)
-è scaricabile dalle **GitHub Releases** del progetto.
+L'"app desktop" di Fantasta è in realtà **due processi Node** (server LAN e
+renderer) avvolti da **Electron**. Il pacchetto npm include tutto e lancia il
+binario Electron ufficiale, firmato da GitHub: per questo non c'è alcun
+**avviso di sicurezza** all'apertura su macOS, Windows o Linux (niente
+Gatekeeper da aggirare). Se preferisci una finestra "installata" a sistema,
+la distribuzione installer (`.dmg`/`.exe`) resta scaricabile dalle **GitHub
+Releases** del progetto.
 
 ## Sviluppo in questo repo
 

package/bin/fantasta.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
-// Launcher Fantasta senza Electron.
+// Launcher "fantasta".
 //
-// L'"app desktop" è, di fatto, due processi Node già inclusi come risorse:
-//   - resources/local-server.cjs  → server SQLite + WebSocket LAN (porta 47821)
-//   - resources/web/**            → renderer Next standalone (porta 47822)
+// Di default avvia la VERA app desktop: avvia Electron con le risorse incluse
+// (resources/app), che apre la finestra della regia e serve server SQLite/LAN
+// (porta 47821) e renderer (porta 47822). Il binario Electron è firmato da
+// GitHub, quindi NIENTE avviso Gatekeeper all'apertura.
 //
-// Questo bin li avvia, crea/riprende la sessione admin, apre la regia nel
-// browser di default e resta in esecuzione finché il segnale non lo ferma.
-// Niente .app, niente binari nativi da firmare: Gatekeeper non ha nulla da
-// bloccare su macOS, Windows o Linux.
+// Con `--browser` (o FANTASTA_BROWSER=1) usa la modalità legacy senza Electron:
+// avvia i due processi Node (local-server.cjs + renderer standalone) e apre la
+// regia nel browser di default. Utile su macchine senza Electron installato.
 "use strict";
 
 const { spawn } = require("node:child_process");
@@ -19,6 +19,7 @@ const path = require("node:path");
 const resourcesRoot = path.resolve(__dirname, "..", "resources");
 const serverEntry = path.join(resourcesRoot, "local-server.cjs");
 const rendererEntry = path.join(resourcesRoot, "web", "apps", "web", "server.js");
+const appDir = path.join(resourcesRoot, "app");
 
 const HOST = "0.0.0.0";
 const LOCAL_PORT = process.env.FANTASTA_PORT ?? "47821";
@@ -30,6 +31,8 @@ const DATA_DIR = process.env.FANTASTA_DATA_DIR ?? path.join(homedir(), ".fantast
 const DB_PATH = process.env.FANTASTA_DATABASE_PATH ?? path.join(DATA_DIR, "fantasta.db");
 const SESSION_FILE = process.env.FANTASTA_SESSION_FILE ?? path.join(DATA_DIR, "admin-session.txt");
 
+const browserMode = process.argv.includes("--browser") || process.env.FANTASTA_BROWSER === "1";
+
 let running = [];
 
 function log(message) {
@@ -40,16 +43,16 @@ function error(message) {
   console.error(`[fantasta] Errore: ${message}`);
 }
 
-async function waitForHealth(url, label, timeoutMs = 20_000) {
+async function waitForHealth(url, label, healthPath = "/api/health", timeoutMs = 30_000) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     try {
-      const response = await fetch(new URL("/api/health", url));
+      const response = await fetch(new URL(healthPath, url));
       if (response.ok) return;
     } catch {
       // il processo si sta ancora avviando
     }
-    await new Promise((resolve) => setTimeout(resolve, 200));
+    await new Promise((resolve) => setTimeout(resolve, 250));
   }
   throw new Error(`Il processo ${label} non ha risposto in tempo`);
 }
@@ -112,11 +115,20 @@ function openBrowser(url) {
   }
 }
 
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function electronBinary() {
+  try {
+    // Quando eseguito da Node, `require("electron")` restituisce il percorso
+    // del binario Electron (non il modulo). Se electron non è installato il
+    // require fallisce e si cade nella modalità browser.
+    const electron = require("electron");
+    return typeof electron === "string" ? electron : null;
+  } catch {
+    return null;
+  }
 }
 
-async function main() {
+async function runBrowserMode() {
+  log("Modalità browser (senza finestra).");
   startServer();
 
   let errorLogged = false;
@@ -135,9 +147,10 @@ async function main() {
     await waitForHealth(LOCAL_URL, "server locale");
     log("Server locale pronto");
     const sessionId = await resolveAdminSession();
-    log(`Sessione admin ${errorLogged ? "" : "pronta"}`);
+    log("Sessione admin pronta");
     startRenderer();
-    await waitForHealth(new URL("/local/home", RENDERER_URL), "renderer");
+    // Il renderer Next NON espone /api/health: si attende la pagina /local/setup.
+    await waitForHealth(RENDERER_URL, "renderer", "/local/setup");
 
     const home = new URL("/local/home", RENDERER_URL);
     home.searchParams.set("server", LOCAL_URL);
@@ -175,4 +188,49 @@ async function main() {
   }
 }
 
+async function runDesktopMode() {
+  const binary = electronBinary();
+  if (!binary) {
+    log("Electron non trovato: passo alla modalità browser.");
+    return runBrowserMode();
+  }
+  // Crea la directory dei dati prima che Electron apra il database.
+  await mkdir(DATA_DIR, { recursive: true });
+  log(`Avvio app desktop (Electron) da ${appDir}`);
+  const child = spawn(binary, [appDir], {
+    env: {
+      ...process.env,
+      FANTASTA_NPM_MODE: "1",
+      FANTASTA_LOCAL_SERVER_URL: LOCAL_URL,
+      FANTASTA_HOST: HOST,
+      FANTASTA_PORT: LOCAL_PORT,
+      FANTASTA_RENDERER_PORT: RENDERER_PORT,
+      FANTASTA_DATABASE_PATH: DB_PATH,
+    },
+    stdio: "inherit",
+  });
+  running.push(child);
+
+  const interrupted = await new Promise((resolve) => {
+    const onSignal = () => {
+      running.forEach((c) => { try { c.kill("SIGTERM"); } catch {} });
+      resolve(true);
+    };
+    child.on("exit", (code, signal) => resolve(code === 0 ? false : true));
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+  });
+  if (interrupted) {
+    log("App desktop chiusa. L'asta è offline.");
+  }
+}
+
+async function main() {
+  if (browserMode) {
+    await runBrowserMode();
+  } else {
+    await runDesktopMode();
+  }
+}
+
 void main();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fantasta",
-  "version": "0.2.0",
-  "description": "Asta di Fantacalcio in LAN senza server: avvia la regia locale e i partecipanti si collegano dal telefono. Nessuna installazione richiesta.",
+  "version": "0.3.0",
+  "description": "Asta di Fantacalcio in LAN senza server: avvia la regia come vera app desktop e i partecipanti si collegano dal telefono. Nessuna installazione richiesta.",
   "license": "MIT",
   "type": "commonjs",
   "bin": {
@@ -16,6 +16,9 @@
   "engines": {
     "node": ">=22.13.0"
   },
+  "dependencies": {
+    "electron": "44.0.0"
+  },
   "scripts": {
     "prepack": "node scripts/prepack.mjs"
   },

package/resources/app/electron/main.cjs

@@ -0,0 +1,364 @@
+const { app, BrowserWindow, dialog, ipcMain, safeStorage, session, shell, utilityProcess } = require("electron");
+const { spawn } = require("node:child_process");
+const { readFile, writeFile, mkdir, copyFile, rename, unlink, access } = require("node:fs/promises");
+const { randomUUID } = require("node:crypto");
+const path = require("node:path");
+const { backup, DatabaseSync } = require("node:sqlite");
+
+const repositoryRoot = path.resolve(__dirname, "../../..");
+const localServerUrl = process.env.FANTASTA_LOCAL_SERVER_URL ?? "http://127.0.0.1:47821";
+let rendererOrigin = process.env.FANTASTA_RENDERER_URL ?? "http://127.0.0.1:3000";
+let localService;
+let rendererService;
+let hostConfig = { sessionId: null, leagueCode: null };
+
+// Modalità "npm" (npx fantasta): Electron gira dal pacchetto npm, NON da un
+// .app impacchettato. Le risorse (local-server.cjs + renderer standalone)
+// stanno fuori da app/: main.cjs vive in resources/app/electron, quindi
+// resourcesRoot = ../../ (= resources/ del pacchetto).
+const npmMode = process.env.FANTASTA_NPM_MODE === "1";
+const bundled = app.isPackaged || npmMode;
+const resourcesRoot = npmMode && !app.isPackaged
+  ? path.resolve(__dirname, "../..")
+  : process.resourcesPath;
+
+function hostConfigPath() {
+  return path.join(app.getPath("userData"), "host.json");
+}
+
+function databasePath() {
+  return process.env.FANTASTA_DATABASE_PATH ?? path.join(app.getPath("userData"), "fantasta.db");
+}
+
+function assertRenderer(event) {
+  const sender = new URL(event.senderFrame.url);
+  if (sender.origin !== assertLoopback(rendererOrigin, "FANTASTA_RENDERER_URL").origin) {
+    throw new Error("Renderer non autorizzato");
+  }
+}
+
+async function exportBackup() {
+  const date = new Date().toISOString().slice(0, 10);
+  const destination = await dialog.showSaveDialog({
+    title: "Esporta backup Fantasta",
+    defaultPath: path.join(app.getPath("documents"), `fantasta-backup-${date}.db`),
+    filters: [{ name: "Database Fantasta", extensions: ["db", "sqlite"] }],
+  });
+  if (destination.canceled || !destination.filePath) return { canceled: true };
+  const database = new DatabaseSync(databasePath(), { timeout: 5_000 });
+  try {
+    const pages = await backup(database, destination.filePath, { rate: 100 });
+    return { canceled: false, path: destination.filePath, pages };
+  } finally {
+    database.close();
+  }
+}
+
+async function fileExists(filePath) {
+  try { await access(filePath); return true; } catch { return false; }
+}
+
+function validateBackup(filePath) {
+  const database = new DatabaseSync(filePath, { readOnly: true, timeout: 5_000 });
+  try {
+    const migrations = database.prepare("SELECT COUNT(*) AS count FROM schema_migrations").get();
+    const leagues = database.prepare("SELECT COUNT(*) AS count FROM leagues").get();
+    if (!migrations || !leagues) throw new Error("Il file non contiene un database Fantasta valido");
+  } finally {
+    database.close();
+  }
+}
+
+async function stopLocalService() {
+  const service = localService;
+  localService = undefined;
+  if (!service || service.exitCode !== null) return;
+  await new Promise((resolve) => {
+    const timeout = setTimeout(() => { try { service.kill(); } catch {} resolve(); }, 5_000);
+    service.once("exit", () => { clearTimeout(timeout); resolve(); });
+    try { service.kill(); } catch {}
+  });
+}
+
+async function stopRendererService() {
+  const service = rendererService;
+  rendererService = undefined;
+  if (!service || service.exitCode !== null) return;
+  await new Promise((resolve) => {
+    const timeout = setTimeout(() => { service.kill("SIGKILL"); resolve(); }, 5_000);
+    service.once("exit", () => { clearTimeout(timeout); resolve(); });
+    service.kill("SIGTERM");
+  });
+}
+
+async function restoreBackup() {
+  if (process.env.FANTASTA_START_LOCAL_SERVER === "0") {
+    throw new Error("Il ripristino richiede il servizio locale gestito da Electron");
+  }
+  const selection = await dialog.showOpenDialog({
+    title: "Ripristina backup Fantasta",
+    properties: ["openFile"],
+    filters: [{ name: "Database Fantasta", extensions: ["db", "sqlite"] }],
+  });
+  if (selection.canceled || !selection.filePaths[0]) return { canceled: true };
+  validateBackup(selection.filePaths[0]);
+  const confirmation = await dialog.showMessageBox({
+    type: "warning",
+    buttons: ["Annulla", "Ripristina"],
+    defaultId: 0,
+    cancelId: 0,
+    title: "Ripristinare questo backup?",
+    message: "L'asta corrente verrà sostituita e tutti i partecipanti dovranno riconnettersi.",
+    detail: "Prima del ripristino verrà conservata una copia di sicurezza del database attuale.",
+  });
+  if (confirmation.response !== 1) return { canceled: true };
+
+  const target = databasePath();
+  const folder = path.dirname(target);
+  const candidate = path.join(folder, `fantasta-restore-${randomUUID()}.tmp`);
+  const safety = path.join(folder, `fantasta-before-restore-${Date.now()}.db`);
+  let previousPath = null;
+  let replacementInstalled = false;
+  try {
+    await stopLocalService();
+    if (await fileExists(target)) {
+      const current = new DatabaseSync(target, { timeout: 5_000 });
+      try { await backup(current, safety, { rate: 100 }); } finally { current.close(); }
+      previousPath = `${target}.pre-restore-${Date.now()}`;
+      await rename(target, previousPath);
+    }
+    await copyFile(selection.filePaths[0], candidate);
+    validateBackup(candidate);
+    await rename(candidate, target);
+    replacementInstalled = true;
+    await Promise.all([unlink(`${target}-wal`).catch(() => {}), unlink(`${target}-shm`).catch(() => {})]);
+    await startLocalService();
+    for (const window of BrowserWindow.getAllWindows()) window.webContents.reloadIgnoringCache();
+    return { canceled: false, safetyPath: await fileExists(safety) ? safety : undefined };
+  } catch (error) {
+    await unlink(candidate).catch(() => {});
+    if (previousPath && await fileExists(previousPath)) {
+      if (replacementInstalled && await fileExists(target)) {
+        await rename(target, `${target}.failed-restore-${Date.now()}`).catch(() => {});
+      }
+      if (!(await fileExists(target))) await rename(previousPath, target).catch(() => {});
+    }
+    if (!localService) await startLocalService().catch(() => {});
+    throw error;
+  }
+}
+
+async function loadHostConfig() {
+  try {
+    const raw = JSON.parse(await readFile(hostConfigPath(), "utf8"));
+    const leagueCode = typeof raw.leagueCode === "string" ? raw.leagueCode : null;
+    if (typeof raw.encryptedSession !== "string" || !(await safeStorage.isAsyncEncryptionAvailable())) {
+      return { sessionId: null, leagueCode };
+    }
+    const decrypted = await safeStorage.decryptStringAsync(Buffer.from(raw.encryptedSession, "base64"));
+    return { sessionId: decrypted.result, leagueCode };
+  } catch {
+    return { sessionId: null, leagueCode: null };
+  }
+}
+
+async function saveHostConfig(update) {
+  hostConfig = { ...hostConfig, ...update };
+  await mkdir(path.dirname(hostConfigPath()), { recursive: true });
+  const payload = { leagueCode: hostConfig.leagueCode };
+  if (hostConfig.sessionId && await safeStorage.isAsyncEncryptionAvailable()) {
+    payload.encryptedSession = (await safeStorage.encryptStringAsync(hostConfig.sessionId)).toString("base64");
+  }
+  await writeFile(hostConfigPath(), JSON.stringify(payload), { mode: 0o600 });
+}
+
+function assertLoopback(value, label) {
+  const url = new URL(value);
+  if (!["127.0.0.1", "localhost", "::1"].includes(url.hostname)) {
+    throw new Error(`${label} deve essere un URL loopback`);
+  }
+  return url;
+}
+
+async function waitForHealth(url) {
+  const deadline = Date.now() + 12_000;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(new URL("/api/health", url));
+      if (response.ok) return;
+    } catch { /* il processo locale sta ancora avviandosi */ }
+    await new Promise((resolve) => setTimeout(resolve, 150));
+  }
+  throw new Error("Il servizio locale non ha risposto in tempo");
+}
+
+async function startLocalService() {
+  if (process.env.FANTASTA_START_LOCAL_SERVER === "0") return;
+  // In sviluppo il server SQLite gira attraverso tsx: NON e un runtime Electron,
+  // quindi lo si mantiene con child_process.spawn (qui l'icona Dock non interessa).
+  if (!bundled) {
+    const entrypoint = path.join(repositoryRoot, "apps/desktop/src/main.ts");
+    localService = spawn(process.execPath, ["--import", "tsx", entrypoint], {
+      cwd: repositoryRoot,
+      env: {
+        ...process.env,
+        ELECTRON_RUN_AS_NODE: "1",
+        FANTASTA_HOST: "0.0.0.0",
+        FANTASTA_PORT: new URL(localServerUrl).port || "47821",
+        FANTASTA_DATABASE_PATH: databasePath(),
+      },
+      stdio: "inherit",
+    });
+    await waitForHealth(localServerUrl);
+    return;
+  }
+  // Nel pacchetto il server locale e un file Node puro: utilityProcess.fork lo
+  // esegue come helper invisibile di Electron, senza icona separata nel Dock
+  // (a differenza di child_process.spawn del binario Electron con RUN_AS_NODE,
+  // che macOS mostra come seconda app "exec").
+  const entrypoint = path.join(resourcesRoot, "local-server.cjs");
+  localService = utilityProcess.fork(entrypoint, [], {
+    env: {
+      ...process.env,
+      FANTASTA_HOST: "0.0.0.0",
+      FANTASTA_PORT: new URL(localServerUrl).port || "47821",
+      FANTASTA_DATABASE_PATH: databasePath(),
+    },
+    stdio: "inherit",
+  });
+  await waitForHealth(localServerUrl);
+}
+
+async function waitForRenderer(url) {
+  const deadline = Date.now() + 20_000;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(new URL("/local/setup", url));
+      if (response.ok) return;
+    } catch { /* Next standalone sta ancora avviandosi */ }
+    await new Promise((resolve) => setTimeout(resolve, 150));
+  }
+  throw new Error("Il renderer locale non ha risposto in tempo");
+}
+
+async function startRendererService() {
+  if (!bundled || process.env.FANTASTA_RENDERER_URL) return;
+  const port = process.env.FANTASTA_RENDERER_PORT ?? "47822";
+  rendererOrigin = `http://127.0.0.1:${port}`;
+  const entrypoint = path.join(resourcesRoot, "web", "apps", "web", "server.js");
+  // Il renderer deve essere raggiungibile dalla LAN: il QR del wizard punta a
+  // http://<IP-locale>:47822, dove i telefoni caricano la vista partecipante.
+  // (In sviluppo il renderer è esposto con `next dev --hostname 0.0.0.0`.)
+  rendererService = spawn(process.execPath, [entrypoint], {
+    env: { ...process.env, ELECTRON_RUN_AS_NODE: "1", HOSTNAME: "0.0.0.0", PORT: port },
+    stdio: "inherit",
+  });
+  await waitForRenderer(rendererOrigin);
+}
+
+async function resolveAdminSession() {
+  const configured = process.env.FANTASTA_ADMIN_SESSION ?? hostConfig.sessionId;
+  if (configured) return configured;
+  const response = await fetch(new URL("/api/session", localServerUrl), { method: "POST" });
+  if (!response.ok) throw new Error("Impossibile creare la sessione admin locale");
+  const payload = await response.json();
+  if (!payload.sessionId) throw new Error("Risposta sessione locale non valida");
+  await saveHostConfig({ sessionId: payload.sessionId });
+  return payload.sessionId;
+}
+
+function createWindow(adminSession) {
+  const rendererUrl = assertLoopback(rendererOrigin, "FANTASTA_RENDERER_URL");
+  const serverUrl = assertLoopback(localServerUrl, "FANTASTA_LOCAL_SERVER_URL");
+  const leagueCode = process.env.FANTASTA_LEAGUE_CODE ?? hostConfig.leagueCode;
+  const window = new BrowserWindow({
+    title: "Fantasta",
+    width: 1440,
+    height: 940,
+    minWidth: 1024,
+    minHeight: 700,
+    show: false,
+    autoHideMenuBar: process.platform !== "darwin",
+    backgroundColor: "#f4f8f5",
+    webPreferences: {
+      preload: path.join(__dirname, "preload.cjs"),
+      contextIsolation: true,
+      sandbox: true,
+      nodeIntegration: false,
+      spellcheck: true,
+    },
+  });
+  // L'app si apre sempre dalla home: da lì si crea una nuova asta oppure si
+  // rientra in regia con la card "Entra nella tua asta" (se c'è una lega salvata).
+  const target = new URL("/local/home", rendererUrl);
+  // `server` serve a setup/regia: senza, le pagine /local mostrano il fallback
+  // "Configurazione desktop mancante".
+  target.searchParams.set("server", serverUrl.toString());
+  if (leagueCode) target.searchParams.set("league", leagueCode);
+  target.searchParams.set("session", adminSession);
+  window.once("ready-to-show", () => window.show());
+  window.webContents.setWindowOpenHandler(({ url }) => {
+    try {
+      const external = new URL(url);
+      if (external.protocol === "https:" && external.hostname === "github.com") {
+        void shell.openExternal(external.toString());
+      }
+    } catch { /* URL non valido: resta bloccato */ }
+    return { action: "deny" };
+  });
+  window.webContents.on("will-navigate", (event, url) => {
+    if (new URL(url).origin !== rendererUrl.origin) event.preventDefault();
+  });
+  void window.loadURL(target.toString());
+}
+
+if (!app.requestSingleInstanceLock()) app.quit();
+else {
+  app.on("second-instance", () => BrowserWindow.getAllWindows()[0]?.focus());
+  app.whenReady().then(async () => {
+    // Da npm l'app gira come binario "Electron": rinominare subito fa sì che
+    // userData (e quindi il database) finisca in ~/Library/Application Support/
+    // Fantasta, come per l'app installata, non in ".../Electron".
+    if (npmMode) app.setName("Fantasta");
+    app.setAboutPanelOptions({
+      applicationName: "Fantasta",
+      applicationVersion: app.getVersion(),
+      copyright: "Copyright © 2026 Davide Pirovano",
+      website: "https://github.com/Davide-Pirovano/fantasta",
+    });
+    // Solo write sanificato della clipboard (il "copia link" nel wizard/regia):
+    // bloccato qui, navigator.clipboard.writeText fallisce in silenzio nel renderer.
+    session.defaultSession.setPermissionRequestHandler((_webContents, permission, callback) => {
+      callback(permission === "clipboard-sanitized-write");
+    });
+    try {
+      hostConfig = await loadHostConfig();
+      await startLocalService();
+      await startRendererService();
+      const adminSession = await resolveAdminSession();
+      ipcMain.handle("fantasta:save-host-config", async (event, update) => {
+        assertRenderer(event);
+        if (!update || typeof update.leagueCode !== "string" || !/^[A-Z0-9]{4,12}$/i.test(update.leagueCode)) throw new Error("Codice lega non valido");
+        await saveHostConfig({ leagueCode: update.leagueCode.toUpperCase() });
+      });
+      ipcMain.handle("fantasta:export-backup", async (event) => {
+        assertRenderer(event);
+        return exportBackup();
+      });
+      ipcMain.handle("fantasta:restore-backup", async (event) => {
+        assertRenderer(event);
+        return restoreBackup();
+      });
+      createWindow(adminSession);
+    } catch (error) {
+      console.error(error);
+      app.quit();
+    }
+  });
+}
+
+app.on("window-all-closed", () => app.quit());
+app.on("before-quit", () => {
+  try { localService?.kill(); } catch {}
+  try { rendererService?.kill("SIGTERM"); } catch {}
+});

package/resources/app/electron/preload.cjs

@@ -0,0 +1,9 @@
+const { contextBridge, ipcRenderer } = require("electron");
+
+// Bridge intenzionalmente minimo: nessun accesso a filesystem, shell o IPC generico.
+contextBridge.exposeInMainWorld("fantastaDesktop", {
+  platform: process.platform,
+  saveHostConfig: (config) => ipcRenderer.invoke("fantasta:save-host-config", config),
+  exportBackup: () => ipcRenderer.invoke("fantasta:export-backup"),
+  restoreBackup: () => ipcRenderer.invoke("fantasta:restore-backup"),
+});

package/resources/app/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "fantasta",
+  "version": "1.0.0",
+  "main": "electron/main.cjs",
+  "private": true
+}