fantasta 0.3.0 → 0.3.2

package/README.md

@@ -13,12 +13,17 @@ pacchetto è firmato da GitHub, quindi non c'è Gatekeeper da aggirare.
 
 ## Cosa succede
 
-- Si apre la **finestra dell'app desktop** (regia);
+- Al **primo avvio** su macOS viene preparata una vera **Fantasta.app** (nome,
+  icona e identificatore corretti) dentro `~/.fantasta/` — pochi secondi, una
+  volta sola;
+- si apre la **finestra dell'app desktop** (regia) con l'icona e il nome di
+  Fantasta nel Dock;
 - 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 (oppure chiudi la finestra).
+- il **terminale torna subito libero**: l'app gira da sola, chiudi la **finestra**
+  per fermare tutto e disconnettere i partecipanti (i log finiscono in
+  `~/.fantasta/desktop.log`).
 
 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
@@ -39,8 +44,9 @@ npx fantasta --browser
 
 ## Dove vengono salvati i dati
 
-- Finestra desktop: `~/Library/Application Support/Fantasta/fantasta.db` (macOS),
-  `%APPDATA%/Fantasta/fantasta.db` (Windows), `~/.config/Fantasta/fantasta.db` (Linux).
+- Tutti i dati (database, sessione admin, log e l'app `Fantasta.app` su macOS)
+  stanno in `~/.fantasta/` (`FANTASTA_DATA_DIR` per cambiare cartella).
+- Finestra desktop: `fantasta.db` in `~/.fantasta/` (o `FANTASTA_DATABASE_PATH`).
 - Modalità browser / sessioni: `~/.fantasta/` (`fantasta.db`, `admin-session.txt`).
 
 ## Opzioni (variabili d'ambiente)
@@ -67,9 +73,12 @@ 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.
+Gatekeeper da aggirare). Su macOS al primo avvio il pacchetto assembla una
+vera `Fantasta.app` (copia del dist Electron con nome e icona corretti): nel
+Dock compare **solo Fantasta**, senza l'icona "exec" né quella generica di
+Electron. 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,18 +1,27 @@
 #!/usr/bin/env node
 // Launcher "fantasta".
 //
-// 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.
+// Su macOS assembla al primo avvio una vera Fantasta.app (copia del dist
+// Electron con plist, nome e icona corretti, rifirmata adhoc) e la lancia
+// in modalità detached: nel Dock compare solo Fantasta con la sua icona,
+// senza il processo "exec" (che su macOS 26 appare quando un processo node
+// resta vivo accanto a Electron) e senza l'icona atomo di Electron.
 //
-// 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.
+// 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.
 "use strict";
 
-const { spawn } = require("node:child_process");
-const { mkdir, readFile, writeFile } = require("node:fs/promises");
+const { spawn, execFileSync } = require("node:child_process");
+const {
+  access,
+  copyFile,
+  mkdir,
+  open,
+  readFile,
+  rm,
+  writeFile,
+} = require("node:fs/promises");
 const { homedir } = require("node:os");
 const path = require("node:path");
 
@@ -43,6 +52,15 @@ function error(message) {
   console.error(`[fantasta] Errore: ${message}`);
 }
 
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function waitForHealth(url, label, healthPath = "/api/health", timeoutMs = 30_000) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -127,6 +145,73 @@ function electronBinary() {
   }
 }
 
+function cliVersion() {
+  try {
+    return require(path.join(__dirname, "..", "package.json")).version;
+  } catch {
+    return "0.0.0";
+  }
+}
+
+// Assemblea una vera Fantasta.app (macOS) dentro DATA_DIR copiando il dist
+// Electron e patchando plist, icona e identificatore, poi rifirma adhoc.
+// Ritorna il percorso del bundle. Se il bundle esiste già e la versione di
+// Electron/risorse non è cambiata, lo riusa.
+async function ensureMacAppBundle(binary) {
+  const distApp = path.resolve(path.dirname(binary), "../.."); // .../dist/Electron.app
+  const electronVersion = await readFile(path.join(path.dirname(distApp), "version"), "utf8").then((v) => v.trim()).catch(() => "unknown");
+  const marker = `${electronVersion}|${cliVersion()}`;
+  const bundlePath = path.join(DATA_DIR, "Fantasta.app");
+  const markerPath = path.join(DATA_DIR, ".bundle-version");
+
+  try {
+    const current = (await readFile(markerPath, "utf8")).trim();
+    if (current === marker && (await fileExists(bundlePath))) return bundlePath;
+  } catch {
+    // nessun marker: si assembla
+  }
+
+  log("Preparazione app Fantasta (solo la prima volta, pochi secondi)...");
+  await rm(bundlePath, { recursive: true, force: true });
+
+  // 1. Copia il dist Electron come base del bundle. Su macOS si usa `ditto`:
+  //    fs.cp risolverebbe i symlink relativi dei framework in percorsi
+  //    assoluti, rendendo il bundle non autonomo (icudtl.dat non trovato).
+  execFileSync("ditto", [distApp, bundlePath], { stdio: "ignore" });
+
+  // 2. Patch dell'Info.plist: nome, icona, identificatore e versione.
+  const plist = path.join(bundlePath, "Contents", "Info.plist");
+  const replacements = [
+    ["CFBundleName", "Fantasta"],
+    ["CFBundleDisplayName", "Fantasta"],
+    ["CFBundleIdentifier", "com.fantasta.desktop"],
+    ["CFBundleIconFile", "icon.icns"],
+    ["CFBundleShortVersionString", cliVersion()],
+    ["CFBundleVersion", cliVersion()],
+  ];
+  for (const [key, value] of replacements) {
+    execFileSync("plutil", ["-replace", key, "-string", value, plist]);
+  }
+
+  // 3. Sostituisci l'icona di default (electron.icns) con quella di Fantasta.
+  await rm(path.join(bundlePath, "Contents", "Resources", "electron.icns"), { force: true });
+  await copyFile(path.join(appDir, "build", "icon.icns"), path.join(bundlePath, "Contents", "Resources", "icon.icns"));
+
+  // 4. Copia le risorse dell'app dentro il bundle: main.cjs/preload/icone in
+  //    Contents/Resources/app, e server + renderer in Contents/Resources.
+  await rm(path.join(bundlePath, "Contents", "Resources", "app"), { recursive: true, force: true });
+  execFileSync("ditto", [appDir, path.join(bundlePath, "Contents", "Resources", "app")], { stdio: "ignore" });
+  await copyFile(serverEntry, path.join(bundlePath, "Contents", "Resources", "local-server.cjs"));
+  await rm(path.join(bundlePath, "Contents", "Resources", "web"), { recursive: true, force: true });
+  execFileSync("ditto", [path.join(resourcesRoot, "web"), path.join(bundlePath, "Contents", "Resources", "web")], { stdio: "ignore" });
+
+  // 5. Rifirma adhoc (la modifica del plist invalida la firma originale).
+  execFileSync("codesign", ["--force", "--deep", "--sign", "-", bundlePath], { stdio: "ignore" });
+
+  await writeFile(markerPath, marker);
+  return bundlePath;
+}
+
 async function runBrowserMode() {
   log("Modalità browser (senza finestra).");
   startServer();
@@ -188,6 +273,38 @@ async function runBrowserMode() {
   }
 }
 
+async function runMacDesktopMode(binary) {
+  try {
+    const bundlePath = await ensureMacAppBundle(binary);
+    const executable = path.join(bundlePath, "Contents", "MacOS", "Electron");
+    const logPath = path.join(DATA_DIR, "desktop.log");
+    const logFd = await open(logPath, "a");
+    log(`Avvio app desktop da ${bundlePath}`);
+    log("App desktop avviata: chiudi la finestra per fermarla.");
+    log(`Log: ${logPath}`);
+    const child = spawn(executable, [`--user-data-dir=${DATA_DIR}`], {
+      env: {
+        ...process.env,
+        FANTASTA_NPM_MODE: "1",
+        FANTASTA_HOST: HOST,
+        FANTASTA_PORT: LOCAL_PORT,
+        FANTASTA_RENDERER_PORT: RENDERER_PORT,
+        FANTASTA_DATABASE_PATH: DB_PATH,
+        FANTASTA_LOCAL_SERVER_URL: LOCAL_URL,
+      },
+      stdio: ["ignore", logFd, logFd],
+      detached: true,
+    });
+    // Il launcher esce subito: se restasse vivo, macOS mostrerebbe un'icona
+    // "exec" nel Dock accanto all'app.
+    child.unref();
+  } catch (cause) {
+    error(cause instanceof Error ? cause.message : String(cause));
+    log("Ripiego sulla modalità browser.");
+    return runBrowserMode();
+  }
+}
+
 async function runDesktopMode() {
   const binary = electronBinary();
   if (!binary) {
@@ -196,6 +313,12 @@ async function runDesktopMode() {
   }
   // Crea la directory dei dati prima che Electron apra il database.
   await mkdir(DATA_DIR, { recursive: true });
+  if (process.platform === "darwin") {
+    await runMacDesktopMode(binary);
+    return;
+  }
+  // Windows/Linux: lancio del binario Electron con le risorse del pacchetto.
+  // (Su queste piattaforme non esiste il problema dell'icona "exec" nel Dock.)
   log(`Avvio app desktop (Electron) da ${appDir}`);
   const child = spawn(binary, [appDir], {
     env: {
@@ -233,4 +356,4 @@ async function main() {
   }
 }
 
-void main();
+void main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fantasta",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "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",

package/resources/app/electron/main.cjs

@@ -1,4 +1,4 @@
-const { app, BrowserWindow, dialog, ipcMain, safeStorage, session, shell, utilityProcess } = require("electron");
+const { app, BrowserWindow, dialog, ipcMain, nativeImage, 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");
@@ -249,8 +249,12 @@ async function startRendererService() {
   // 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 },
+  // utilityProcess.fork, come per il server locale, evita la seconda icona
+  // "exec" nel Dock di macOS (spawn del binario Electron con RUN_AS_NODE la
+  // creerebbe).
+  rendererService = utilityProcess.fork(entrypoint, [], {
+    cwd: path.join(resourcesRoot, "web"),
+    env: { ...process.env, HOSTNAME: "0.0.0.0", PORT: port },
     stdio: "inherit",
   });
   await waitForRenderer(rendererOrigin);
@@ -267,6 +271,22 @@ async function resolveAdminSession() {
   return payload.sessionId;
 }
 
+// Icona dell'app quando si gira dal bundle Electron generico (modalità npm).
+// Nel pacchetto .dmg/.exe l'icona arriva già dal bundle, qui va impostata a mano.
+function applyAppIcon(window) {
+  if (process.platform === "darwin") {
+    try {
+      const image = nativeImage.createFromPath(path.join(__dirname, "..", "build", "icon.icns"));
+      if (!image.isEmpty() && app.dock) app.dock.setIcon(image);
+    } catch { /* icona opzionale */ }
+  } else if (window) {
+    const icon = process.platform === "win32"
+      ? path.join(__dirname, "..", "build", "icon.ico")
+      : path.join(__dirname, "..", "build", "icon.icns");
+    try { window.setIcon(nativeImage.createFromPath(icon)); } catch { /* icona opzionale */ }
+  }
+}
+
 function createWindow(adminSession) {
   const rendererUrl = assertLoopback(rendererOrigin, "FANTASTA_RENDERER_URL");
   const serverUrl = assertLoopback(localServerUrl, "FANTASTA_LOCAL_SERVER_URL");
@@ -288,6 +308,7 @@ function createWindow(adminSession) {
       spellcheck: true,
     },
   });
+  if (npmMode) applyAppIcon(window);
   // 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);
@@ -314,12 +335,12 @@ function createWindow(adminSession) {
 
 if (!app.requestSingleInstanceLock()) app.quit();
 else {
+  // 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.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(),