chore: release v1.1.0

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.gitignore

@@ -22,5 +22,8 @@ Thumbs.db
 .vscode/
 .idea/
 
+# Token local (jamais commité)
+.gitea-token
+
 # Claude Code
 .claude/

lib/dropstats.js

@@ -21,12 +21,14 @@ function mergeDropStatsInto(target, source) {
 
   for (const [mobName, mobData] of Object.entries(sourceMobs)) {
     if (!mobName) continue;
-    if (!target.mobs[mobName]) target.mobs[mobName] = { kills: 0, items: {} };
+    if (!target.mobs[mobName]) target.mobs[mobName] = { kills: 0, totalExp: 0, totalCols: 0, items: {} };
     const t = target.mobs[mobName];
 
     const kills = Number(mobData.kills) || 0;
     t.kills += kills;
     addedKills += kills;
+    t.totalExp = (t.totalExp || 0) + (Number(mobData.totalExp) || 0);
+    t.totalCols = (t.totalCols || 0) + (Number(mobData.totalCols) || 0);
 
     const items = mobData.items || {};
     for (const [key, item] of Object.entries(items)) {

main.js

@@ -4,24 +4,25 @@ const fs = require('fs');
 const fsp = fs.promises;
 const { emptyDropStats, mergeDropStatsInto } = require('./lib/dropstats');
 
-// Stocké automatiquement dans ~/.config/farm-tracker/ sur Linux (géré par Electron).
 const userDataDir = app.getPath('userData');
-const APP_STATE_FILE = path.join(userDataDir, 'app-state.json');
+
-const DROPSTATS_FILE = path.join(userDataDir, 'dropstats.json');
+// Fichiers globaux (non liés à un profil)
 const COMMUNITY_DROPSTATS_FILE = path.join(userDataDir, 'community-dropstats.json');
-const SESSION_HISTORY_FILE = path.join(userDataDir, 'session-history.json');
+const UPDATE_PREFS_FILE        = path.join(userDataDir, 'update-prefs.json');
-const UPDATE_PREFS_FILE = path.join(userDataDir, 'update-prefs.json');
+const PROFILES_FILE            = path.join(userDataDir, 'profiles.json');
+
+// Fichiers legacy (profil "default")
+const LEGACY_APP_STATE_FILE      = path.join(userDataDir, 'app-state.json');
+const LEGACY_DROPSTATS_FILE      = path.join(userDataDir, 'dropstats.json');
+const LEGACY_SESSION_HISTORY_FILE= path.join(userDataDir, 'session-history.json');
 
 const RELEASES_API = 'https://git.shamiiow.com/api/v1/repos/shamiiow/farm-tracker-sao/releases/latest';
 
-// ---------- Lecture / écriture disque (JSON indenté = facilement lisible) ----------
+// ---------- Lecture / écriture disque ----------
 
 function readJsonSafe(filePath, fallback) {
-  try {
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); }
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  catch { return fallback; }
-  } catch (e) {
-    return fallback;
-  }
 }
 
 function writeJsonAtomic(filePath, obj) {
@@ -37,22 +38,82 @@ function writeJsonAtomic(filePath, obj) {
   }
 }
 
-function loadAppState() { return readJsonSafe(APP_STATE_FILE, null); }
+function tryUnlink(filePath) { try { fs.unlinkSync(filePath); } catch (_) {} }
-function saveAppState(obj) { return writeJsonAtomic(APP_STATE_FILE, obj); }
+
-function loadDropStats() { return readJsonSafe(DROPSTATS_FILE, emptyDropStats()); }
+function generateId() {
-function saveDropStats(obj) { return writeJsonAtomic(DROPSTATS_FILE, obj); }
+  return Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
-function loadCommunityDropStats() { return readJsonSafe(COMMUNITY_DROPSTATS_FILE, null); }
+}
+
+// ---------- Profils ----------
+
+function emptyProfilesData() {
+  return {
+    activeProfileId: 'default',
+    profiles: [{
+      id: 'default',
+      name: 'Défaut',
+      dropStatsMode: 'private',
+      createdAt: new Date().toISOString()
+    }]
+  };
+}
+
+function loadProfilesData() {
+  const data = readJsonSafe(PROFILES_FILE, null);
+  if (!data) {
+    const def = emptyProfilesData();
+    writeJsonAtomic(PROFILES_FILE, def);
+    return def;
+  }
+  // compat : s'assurer que le profil default existe toujours
+  if (!data.profiles.find(p => p.id === 'default')) {
+    data.profiles.unshift({ id: 'default', name: 'Défaut', dropStatsMode: 'private', createdAt: new Date().toISOString() });
+    writeJsonAtomic(PROFILES_FILE, data);
+  }
+  return data;
+}
+
+function getActiveProfile() {
+  const data = loadProfilesData();
+  return data.profiles.find(p => p.id === data.activeProfileId) || data.profiles[0];
+}
+
+// ---------- Chemins de fichiers dynamiques selon profil ----------
+
+function profileAppStateFile(p) {
+  if (!p || p.id === 'default') return LEGACY_APP_STATE_FILE;
+  return path.join(userDataDir, `app-state-${p.id}.json`);
+}
+
+function profileDropStatsFile(p) {
+  if (!p || p.id === 'default') return LEGACY_DROPSTATS_FILE;
+  if (p.dropStatsMode === 'shared') return path.join(userDataDir, 'dropstats-shared.json');
+  return path.join(userDataDir, `dropstats-${p.id}.json`);
+}
+
+function profileSessionHistoryFile(p) {
+  if (!p || p.id === 'default') return LEGACY_SESSION_HISTORY_FILE;
+  return path.join(userDataDir, `session-history-${p.id}.json`);
+}
+
+// ---------- Load / save avec profil actif ----------
+
+function loadAppState()        { return readJsonSafe(profileAppStateFile(getActiveProfile()), null); }
+function saveAppState(obj)     { return writeJsonAtomic(profileAppStateFile(getActiveProfile()), obj); }
+function loadDropStats()       { return readJsonSafe(profileDropStatsFile(getActiveProfile()), emptyDropStats()); }
+function saveDropStats(obj)    { return writeJsonAtomic(profileDropStatsFile(getActiveProfile()), obj); }
+function loadSessionHistory()  { return readJsonSafe(profileSessionHistoryFile(getActiveProfile()), { type: 'farm-tracker-session-history', version: 1, sessions: [] }); }
+function saveSessionHistory(o) { return writeJsonAtomic(profileSessionHistoryFile(getActiveProfile()), o); }
+function loadCommunityDropStats()    { return readJsonSafe(COMMUNITY_DROPSTATS_FILE, null); }
 function saveCommunityDropStats(obj) { return writeJsonAtomic(COMMUNITY_DROPSTATS_FILE, obj); }
-function loadSessionHistory() { return readJsonSafe(SESSION_HISTORY_FILE, { type: 'farm-tracker-session-history', version: 1, sessions: [] }); }
+function loadUpdatePrefs()     { return readJsonSafe(UPDATE_PREFS_FILE, { snoozedUntil: null }); }
-function saveSessionHistory(obj) { return writeJsonAtomic(SESSION_HISTORY_FILE, obj); }
+function saveUpdatePrefs(obj)  { return writeJsonAtomic(UPDATE_PREFS_FILE, obj); }
-function loadUpdatePrefs() { return readJsonSafe(UPDATE_PREFS_FILE, { snoozedUntil: null }); }
-function saveUpdatePrefs(obj) { return writeJsonAtomic(UPDATE_PREFS_FILE, obj); }
 
 function resolveLogPath(folderPath) {
-  const candidate1 = path.join(folderPath, 'logs', 'latest.log');
+  const c1 = path.join(folderPath, 'logs', 'latest.log');
-  const candidate2 = path.join(folderPath, 'latest.log');
+  const c2 = path.join(folderPath, 'latest.log');
-  if (fs.existsSync(candidate1)) return candidate1;
+  if (fs.existsSync(c1)) return c1;
-  if (fs.existsSync(candidate2)) return candidate2;
+  if (fs.existsSync(c2)) return c2;
   return null;
 }
 
@@ -138,11 +199,7 @@ function downloadFileWithProgress(url, destPath, onProgress) {
 
 async function downloadAndInstall(downloadUrl, version) {
   if (!app.isPackaged) {
-    dialog.showMessageBox(mainWindow, {
+    dialog.showMessageBox(mainWindow, { type: 'info', title: 'Mode développement', message: 'Auto-install non disponible en mode dev.', buttons: ['OK'] });
-      type: 'info', title: 'Mode développement',
-      message: 'Auto-install non disponible en mode dev.',
-      buttons: ['OK']
-    });
     return;
   }
   const ext = process.platform === 'win32' ? '.exe' : '.AppImage';
@@ -153,16 +210,9 @@ async function downloadAndInstall(downloadUrl, version) {
     sendUpdateProgress(100, 'installing');
     if (process.platform === 'linux') {
       fs.chmodSync(tmpPath, 0o755);
-      const stablePath = path.join(require('os').homedir(), '.local', 'bin', 'farm-tracker.AppImage');
+      const { spawn } = require('child_process');
-      const target = fs.existsSync(stablePath) ? stablePath : process.env.APPIMAGE;
+      spawn(tmpPath, [], { detached: true, stdio: 'ignore' }).unref();
-      if (target) {
+      app.quit();
-        fs.copyFileSync(tmpPath, target);
-        fs.unlinkSync(tmpPath);
-        app.relaunch({ execPath: target });
-      } else {
-        app.relaunch({ execPath: tmpPath });
-      }
-      app.exit(0);
     } else if (process.platform === 'win32') {
       const { spawn } = require('child_process');
       spawn(tmpPath, ['/S'], { detached: true, stdio: 'ignore' }).unref();
@@ -176,44 +226,28 @@ async function downloadAndInstall(downloadUrl, version) {
 async function showUpdateDialog(version, downloadUrl, ignoreSnooze = false) {
   const current = app.getVersion();
   if (!isNewerVersion(version, current)) return false;
-
   if (!ignoreSnooze) {
     const prefs = loadUpdatePrefs();
     if (prefs.snoozedUntil === 'indefinite') return false;
     if (prefs.snoozedUntil && new Date(prefs.snoozedUntil) > new Date()) return false;
   }
-
   const { response } = await dialog.showMessageBox(mainWindow, {
-    type: 'info',
+    type: 'info', title: 'Mise à jour disponible', message: `Version ${version} disponible`,
-    title: 'Mise à jour disponible',
-    message: `Version ${version} disponible`,
     detail: `Version actuelle : ${current}\nL'application se relancera automatiquement après la mise à jour.`,
-    buttons: ['Installer maintenant', 'Me rappeler dans...'],
+    buttons: ['Installer maintenant', 'Me rappeler dans...'], defaultId: 0, cancelId: 1
-    defaultId: 0,
-    cancelId: 1
   });
-
+  if (response === 0) { downloadAndInstall(downloadUrl, version); return true; }
-  if (response === 0) {
-    downloadAndInstall(downloadUrl, version);
-    return true;
-  }
-
   const { response: snoozeResponse } = await dialog.showMessageBox(mainWindow, {
-    type: 'question',
+    type: 'question', title: 'Me rappeler dans...',
-    title: 'Me rappeler dans...',
     message: 'Ne plus afficher cette mise à jour pendant :',
-    buttons: SNOOZE_OPTIONS.map(o => o.label),
+    buttons: SNOOZE_OPTIONS.map(o => o.label), defaultId: 0, cancelId: SNOOZE_OPTIONS.length - 1
-    defaultId: 0,
-    cancelId: SNOOZE_OPTIONS.length - 1
   });
-
   const chosen = SNOOZE_OPTIONS[snoozeResponse];
   if (chosen.days === -1) return false;
   if (chosen.days === null) {
     saveUpdatePrefs({ snoozedUntil: 'indefinite' });
   } else {
-    const until = new Date();
+    const until = new Date(); until.setDate(until.getDate() + chosen.days);
-    until.setDate(until.getDate() + chosen.days);
     saveUpdatePrefs({ snoozedUntil: until.toISOString() });
   }
   return false;
@@ -226,39 +260,46 @@ async function checkForUpdates(ignoreSnooze = false) {
     const downloadUrl = resolveAssetUrl(release);
     if (!version || !downloadUrl) return false;
     return await showUpdateDialog(version, downloadUrl, ignoreSnooze);
-  } catch (_) {
+  } catch (_) { return false; }
-    return false;
-  }
 }
 
 let mainWindow;
 
 function createWindow() {
   mainWindow = new BrowserWindow({
-    width: 1180,
+    width: 1180, height: 880, minWidth: 760, minHeight: 600,
-    height: 880,
+    backgroundColor: '#0B0F0C', autoHideMenuBar: true,
-    minWidth: 760,
-    minHeight: 600,
-    backgroundColor: '#0B0F0C',
-    autoHideMenuBar: true,
     webPreferences: {
       preload: path.join(__dirname, 'preload.js'),
-      contextIsolation: true,
+      contextIsolation: true, nodeIntegration: false
-      nodeIntegration: false
     }
   });
   mainWindow.setMenuBarVisibility(false);
   mainWindow.loadFile(path.join(__dirname, 'renderer', 'index.html'));
 }
 
+function selfInstallLinux() {
+  if (process.platform !== 'linux' || !app.isPackaged) return;
+  const appImagePath = process.env.APPIMAGE;
+  if (!appImagePath) return;
+  const stablePath = path.join(require('os').homedir(), '.local', 'bin', 'farm-tracker.AppImage');
+  if (appImagePath === stablePath) return;
+  try {
+    fs.mkdirSync(path.dirname(stablePath), { recursive: true });
+    fs.copyFileSync(appImagePath, stablePath);
+    fs.chmodSync(stablePath, 0o755);
+  } catch (_) {}
+}
+
 app.whenReady().then(() => {
+  selfInstallLinux();
   createWindow();
   setTimeout(() => checkForUpdates(false), 5000);
 });
 app.on('window-all-closed', () => { if (process.platform !== 'darwin') app.quit(); });
 app.on('activate', () => { if (BrowserWindow.getAllWindows().length === 0) createWindow(); });
 
-// ---------- IPC : sélection et lecture du dossier Minecraft ----------
+// ---------- IPC : dossier Minecraft ----------
 
 ipcMain.handle('pick-folder', async () => {
   const result = await dialog.showOpenDialog(mainWindow, {
@@ -268,18 +309,13 @@ ipcMain.handle('pick-folder', async () => {
   if (result.canceled || !result.filePaths.length) return { canceled: true };
   const folder = result.filePaths[0];
   const logPath = resolveLogPath(folder);
-  if (!logPath) {
+  if (!logPath) return { canceled: false, error: 'Impossible de trouver "latest.log" dans ce dossier ni dans son sous-dossier "logs". Sélectionne ton dossier .minecraft, ou le dossier logs directement.' };
-    return {
-      canceled: false,
-      error: 'Impossible de trouver "latest.log" dans ce dossier ni dans son sous-dossier "logs". Sélectionne ton dossier .minecraft, ou le dossier logs directement.'
-    };
-  }
   return { canceled: false, logPath };
 });
 
 ipcMain.handle('check-log-path', async (event, logPath) => {
   try { await fsp.access(logPath, fs.constants.R_OK); return { ok: true }; }
-  catch (e) { return { ok: false }; }
+  catch { return { ok: false }; }
 });
 
 ipcMain.handle('get-file-size', async (event, logPath) => {
@@ -296,52 +332,38 @@ ipcMain.handle('read-chunk', async (event, logPath, start, end) => {
     const buffer = Buffer.alloc(length);
     await fd.read(buffer, 0, length, start);
     return { text: buffer.toString('utf8') };
-  } catch (e) {
+  } catch (e) { return { text: '', error: e.message }; }
-    return { text: '', error: e.message };
+  finally { if (fd) await fd.close().catch(() => {}); }
-  } finally {
-    if (fd) await fd.close().catch(() => {});
-  }
 });
 
-// ---------- IPC : état général de l'appli ----------
+// ---------- IPC : état application (par profil) ----------
 
-ipcMain.handle('load-app-state', async () => loadAppState());
+ipcMain.handle('load-app-state',  async () => loadAppState());
-ipcMain.handle('save-app-state', async (event, obj) => saveAppState(obj));
+ipcMain.handle('save-app-state',  async (_, obj) => saveAppState(obj));
 
-// ---------- IPC : stats de chance de drop personnelles ----------
+// ---------- IPC : drop stats (par profil) ----------
 
 ipcMain.handle('load-drop-stats', async () => loadDropStats());
-ipcMain.handle('save-drop-stats', async (event, obj) => saveDropStats(obj));
+ipcMain.handle('save-drop-stats', async (_, obj) => saveDropStats(obj));
 
 ipcMain.handle('export-drop-stats', async () => {
   const current = loadDropStats();
   const defaultName = 'farm-tracker-dropstats-' + new Date().toISOString().slice(0, 10) + '.json';
-  const result = await dialog.showSaveDialog(mainWindow, {
+  const result = await dialog.showSaveDialog(mainWindow, { title: 'Exporter mes stats de chance de drop', defaultPath: defaultName, filters: [{ name: 'JSON', extensions: ['json'] }] });
-    title: 'Exporter mes stats de chance de drop',
-    defaultPath: defaultName,
-    filters: [{ name: 'JSON', extensions: ['json'] }]
-  });
   if (result.canceled || !result.filePath) return { canceled: true };
   fs.writeFileSync(result.filePath, JSON.stringify(current, null, 2));
   return { canceled: false, filePath: result.filePath };
 });
 
 ipcMain.handle('import-merge-drop-stats', async () => {
-  const result = await dialog.showOpenDialog(mainWindow, {
+  const result = await dialog.showOpenDialog(mainWindow, { title: 'Importer et fusionner des fichiers de stats de drop', properties: ['openFile', 'multiSelections'], filters: [{ name: 'JSON', extensions: ['json'] }] });
-    title: 'Importer et fusionner des fichiers de stats de drop (plusieurs fichiers possibles)',
-    properties: ['openFile', 'multiSelections'],
-    filters: [{ name: 'JSON', extensions: ['json'] }]
-  });
   if (result.canceled || !result.filePaths.length) return { canceled: true };
-
   const current = loadDropStats();
   const details = [];
   let totalAdded = 0;
-
   for (const filePath of result.filePaths) {
     try {
-      const raw = fs.readFileSync(filePath, 'utf8');
+      const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-      const data = JSON.parse(raw);
       const added = mergeDropStatsInto(current, data);
       totalAdded += added;
       details.push({ file: path.basename(filePath), addedKills: added, ok: true });
@@ -349,23 +371,82 @@ ipcMain.handle('import-merge-drop-stats', async () => {
       details.push({ file: path.basename(filePath), ok: false, error: e.message });
     }
   }
-
   current.updatedAt = new Date().toISOString();
   saveDropStats(current);
-
   return { canceled: false, totalAdded, details, dropStats: current };
 });
 
-// ---------- IPC : stats communautaires (reçues du serveur de sync) ----------
+// ---------- IPC : stats communautaires (globales) ----------
 
-ipcMain.handle('load-community-drop-stats', async () => loadCommunityDropStats());
+ipcMain.handle('load-community-drop-stats',  async () => loadCommunityDropStats());
-ipcMain.handle('save-community-drop-stats', async (event, obj) => saveCommunityDropStats(obj));
+ipcMain.handle('save-community-drop-stats',  async (_, obj) => saveCommunityDropStats(obj));
-ipcMain.handle('get-file-paths', () => ({ dropStats: DROPSTATS_FILE, communityDropStats: COMMUNITY_DROPSTATS_FILE }));
+ipcMain.handle('get-file-paths', () => ({
+  dropStats: profileDropStatsFile(getActiveProfile()),
+  communityDropStats: COMMUNITY_DROPSTATS_FILE
+}));
 
-// ---------- IPC : historique des sessions ----------
+// ---------- IPC : historique des sessions (par profil) ----------
 
 ipcMain.handle('load-session-history', async () => loadSessionHistory());
-ipcMain.handle('save-session-history', async (event, obj) => saveSessionHistory(obj));
+ipcMain.handle('save-session-history', async (_, obj) => saveSessionHistory(obj));
+
+// ---------- IPC : profils ----------
+
+ipcMain.handle('get-profiles', () => loadProfilesData());
+
+ipcMain.handle('create-profile', (_, { name, dropStatsMode }) => {
+  const data = loadProfilesData();
+  const newProfile = {
+    id: generateId(),
+    name: (name || 'Nouveau profil').trim().slice(0, 40),
+    dropStatsMode: dropStatsMode === 'shared' ? 'shared' : 'private',
+    createdAt: new Date().toISOString()
+  };
+  data.profiles.push(newProfile);
+  writeJsonAtomic(PROFILES_FILE, data);
+  return data;
+});
+
+ipcMain.handle('switch-profile', (_, id) => {
+  const data = loadProfilesData();
+  if (!data.profiles.find(p => p.id === id)) return { ok: false, error: 'Profil introuvable' };
+  data.activeProfileId = id;
+  writeJsonAtomic(PROFILES_FILE, data);
+  return { ok: true };
+});
+
+ipcMain.handle('rename-profile', (_, { id, name }) => {
+  const data = loadProfilesData();
+  const profile = data.profiles.find(p => p.id === id);
+  if (!profile) return { ok: false };
+  profile.name = (name || '').trim().slice(0, 40) || profile.name;
+  writeJsonAtomic(PROFILES_FILE, data);
+  return { ok: true, profile };
+});
+
+ipcMain.handle('delete-profile', (_, id) => {
+  if (id === 'default') return { ok: false, error: 'Le profil Défaut ne peut pas être supprimé.' };
+  const data = loadProfilesData();
+  const profile = data.profiles.find(p => p.id === id);
+  if (!profile) return { ok: false, error: 'Profil introuvable' };
+  data.profiles = data.profiles.filter(p => p.id !== id);
+  if (data.activeProfileId === id) data.activeProfileId = 'default';
+  // supprimer les fichiers du profil
+  tryUnlink(path.join(userDataDir, `app-state-${id}.json`));
+  tryUnlink(path.join(userDataDir, `dropstats-${id}.json`));
+  tryUnlink(path.join(userDataDir, `session-history-${id}.json`));
+  writeJsonAtomic(PROFILES_FILE, data);
+  return { ok: true, newActiveId: data.activeProfileId };
+});
+
+ipcMain.handle('set-drop-stats-mode', (_, { id, mode }) => {
+  const data = loadProfilesData();
+  const profile = data.profiles.find(p => p.id === id);
+  if (!profile) return { ok: false };
+  profile.dropStatsMode = mode === 'shared' ? 'shared' : 'private';
+  writeJsonAtomic(PROFILES_FILE, data);
+  return { ok: true };
+});
 
 // ---------- IPC : mise à jour ----------
 
@@ -375,28 +456,20 @@ ipcMain.handle('check-update-manual', async () => {
     const version = (release.tag_name || '').replace(/^v/, '');
     const downloadUrl = resolveAssetUrl(release);
     const current = app.getVersion();
-    if (!version || !downloadUrl || !isNewerVersion(version, current)) {
+    if (!version || !downloadUrl || !isNewerVersion(version, current)) return { checked: true, hasUpdate: false, current };
-      return { checked: true, hasUpdate: false, current };
-    }
     await showUpdateDialog(version, downloadUrl, true);
     return { checked: true, hasUpdate: true };
-  } catch (e) {
+  } catch (e) { return { checked: false, error: e.message }; }
-    return { checked: false, error: e.message };
-  }
 });
 
-// ---------- IPC : sync avec le serveur VPS ----------
+// ---------- IPC : sync VPS ----------
 
-ipcMain.handle('fetch-community-stats', async (event, { serverUrl }) => {
+ipcMain.handle('fetch-community-stats', async (_, { serverUrl }) => {
   return new Promise((resolve) => {
     try {
       const url = new URL('/stats', serverUrl);
       const mod = url.protocol === 'https:' ? require('https') : require('http');
-      const req = mod.get({
+      const req = mod.get({ hostname: url.hostname, port: url.port || (url.protocol === 'https:' ? 443 : 80), path: '/stats' }, (res) => {
-        hostname: url.hostname,
-        port: url.port || (url.protocol === 'https:' ? 443 : 80),
-        path: '/stats'
-      }, (res) => {
         let data = '';
         res.on('data', chunk => { data += chunk; });
         res.on('end', () => {
@@ -406,27 +479,20 @@ ipcMain.handle('fetch-community-stats', async (event, { serverUrl }) => {
       });
       req.setTimeout(15000, () => { req.destroy(); resolve({ ok: false, error: 'Timeout (15s)' }); });
       req.on('error', (e) => resolve({ ok: false, error: e.message }));
-    } catch (e) {
+    } catch (e) { resolve({ ok: false, error: e.message }); }
-      resolve({ ok: false, error: e.message });
-    }
   });
 });
 
-ipcMain.handle('sync-drop-stats', async (event, { serverUrl, clientId, dropStats }) => {
+ipcMain.handle('sync-drop-stats', async (_, { serverUrl, clientId, dropStats }) => {
   return new Promise((resolve) => {
     try {
       const url = new URL('/sync', serverUrl);
       const body = JSON.stringify({ clientId, dropStats });
       const mod = url.protocol === 'https:' ? require('https') : require('http');
       const options = {
-        hostname: url.hostname,
+        hostname: url.hostname, port: url.port || (url.protocol === 'https:' ? 443 : 80),
-        port: url.port || (url.protocol === 'https:' ? 443 : 80),
+        path: '/sync', method: 'POST',
-        path: '/sync',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) }
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Content-Length': Buffer.byteLength(body)
-        }
       };
       const req = mod.request(options, (res) => {
         let data = '';
@@ -438,10 +504,7 @@ ipcMain.handle('sync-drop-stats', async (event, { serverUrl, clientId, dropStats
       });
       req.setTimeout(15000, () => { req.destroy(); resolve({ ok: false, error: 'Timeout (15s)' }); });
       req.on('error', (e) => resolve({ ok: false, error: e.message }));
-      req.write(body);
+      req.write(body); req.end();
-      req.end();
+    } catch (e) { resolve({ ok: false, error: e.message }); }
-    } catch (e) {
-      resolve({ ok: false, error: e.message });
-    }
   });
 });

package.json

@@ -1,6 +1,6 @@
 {
   "name": "farm-tracker",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "Suivi de loot Minecraft en direct, avec sauvegarde automatique des stats et des chances de drop.",
   "main": "main.js",
   "scripts": {

preload.js

@@ -25,5 +25,12 @@ contextBridge.exposeInMainWorld('api', {
   saveSessionHistory: (obj) => ipcRenderer.invoke('save-session-history', obj),
 
   checkUpdateManual: () => ipcRenderer.invoke('check-update-manual'),
-  onUpdateProgress: (cb) => ipcRenderer.on('update-progress', (_, data) => cb(data))
+  onUpdateProgress: (cb) => ipcRenderer.on('update-progress', (_, data) => cb(data)),
+
+  getProfiles:      ()              => ipcRenderer.invoke('get-profiles'),
+  createProfile:    (name, mode)    => ipcRenderer.invoke('create-profile', { name, dropStatsMode: mode }),
+  switchProfile:    (id)            => ipcRenderer.invoke('switch-profile', id),
+  renameProfile:    (id, name)      => ipcRenderer.invoke('rename-profile', { id, name }),
+  deleteProfile:    (id)            => ipcRenderer.invoke('delete-profile', id),
+  setDropStatsMode: (id, mode)      => ipcRenderer.invoke('set-drop-stats-mode', { id, mode }),
 });