senke/veza
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
veza/veza-desktop/AUDIT_REPORT.md
senke 2dfde29f7d refonte: backend-api go first; phase 1
2025-12-12 21:34:34 -05:00

28 KiB
Raw Blame History

🔍 Audit Technique Exhaustif — Module Veza Desktop

Date: 2024-12-19
Module: veza-desktop
Type: Electron Wrapper Application
Auditeur: Technical Audit System

📋 Table des matières

  1. Module Overview
  2. Runbook Minimal
  3. Health/Build/Test Status
  4. Security Findings
  5. Observability & Production Readiness
  6. Performance Notes
  7. Issue List Priorisée (P0→P3)
  8. Execution Plan

Module Overview

But du module

Veza Desktop est un wrapper Electron léger qui charge l'application web Veza (apps/web) dans une fenêtre native. Il ne contient aucune logique UI unique — c'est un shell natif minimaliste.

Rôle exact :

  • Wrapper Electron pour l'app web Veza
  • Gestion du cycle de vie de l'application (fenêtre, shortcuts, auto-update)
  • Bridge entre le processus principal et le renderer (via preload)
  • Distribution multi-plateforme (Windows, macOS, Linux)

Entrées / Sorties

APIs exposées :

  • Aucune API HTTP/WS/gRPC (wrapper uniquement)
  • IPC Electron : communication main ↔ renderer via preload (actuellement vide)

Formats :

  • Charge l'app web via loadURL() (dev) ou loadFile() (prod)
  • Dev : http://localhost:5173 (configurable via VITE_DEV_SERVER_URL)
  • Prod : ../renderer/index.html (chemin relatif)

Dépendances internes

  • Aucune dépendance interne (module isolé)
  • Attend que apps/web soit buildé et accessible

Dépendances externes

  • Electron ^25.0.0 (vulnérable, voir P0)
  • electron-updater ^6.0.0 (auto-update)
  • electron-builder ^24.0.0 (packaging)
  • TypeScript ^4.9.0 (compilation)
  • Node.js (runtime Electron)

Exécution

Commandes :

# Dev
npm run dev:main          # Compile TS + lance Electron
npm run dev               # Dev complet (nécessite apps/web en parallèle)

# Build
npm run build             # Compile TypeScript uniquement
npm run build:main        # Alias de build
npm run dist              # Package avec electron-builder
npm run dist:win|mac|linux # Package spécifique

# Production
npm start                 # Lance Electron (après build)

Configuration :

  • Env vars : VITE_DEV_SERVER_URL (optionnel, défaut: http://localhost:5173)
  • Config build : package.json → build (electron-builder)
  • TypeScript : tsconfig.main.json
  • Icons : assets/icon.{ico,icns,png} (non vérifiés)

Points d'intégration

Avec apps/web :

  • Dev : Charge http://localhost:5173 (doit être running)
  • Prod : Charge ../renderer/index.html (doit être copié dans dist/renderer/)
  • Contrat : Aucun contrat explicite — dépendance implicite fragile

Auth :

  • Aucune gestion d'auth dans le wrapper
  • L'app web gère l'auth (JWT probablement)

CORS/CSP :

  • Aucune configuration CSP dans Electron
  • webSecurity: true par défaut (OK)
  • contextIsolation: true (OK)
  • nodeIntegration: false (OK)

Runbook Minimal

Développement

# Terminal 1: Lancer l'app web
cd ../apps/web
npm run dev  # Doit être sur port 5173

# Terminal 2: Lancer le wrapper
cd veza-desktop
npm install
npm run dev:main

Build Production

# 1. Build l'app web
cd ../apps/web
npm run build
# Vérifier que dist/ existe

# 2. Copier dist/ vers veza-desktop/dist/renderer/ (MANUEL actuellement)
# OU configurer electron-builder pour le faire automatiquement

# 3. Build le wrapper
cd veza-desktop
npm run build
npm run dist

Troubleshooting

  • Erreur "Failed to load local dev server" : Vérifier que apps/web tourne sur port 5173
  • Erreur "Cannot find module" : npm install manquant
  • Build échoue : Vérifier tsconfig.main.json (rootDir incorrect)

Health/Build/Test Status

❌ Build Status: BROKEN

Problèmes critiques :

  1. TypeScript non installé globalement : tsc: command not found

    • Fichier : package.json ligne 11
    • Cause : TypeScript est en devDependencies mais pas accessible dans PATH
    • Impact : Build impossible sans npm install préalable

  2. tsconfig.main.json incohérent :

    • Fichier : tsconfig.main.json ligne 9
    • Problème : rootDir: "./src" mais fichiers dans ./electron/
    • Impact : Compilation peut échouer ou générer mauvais output

⚠️ Test Status: PARTIEL

Tests E2E présents :

  • tests/e2e/library-enhanced.spec.ts (9 tests)
  • tests/e2e/playlists.spec.ts (7 tests)
  • tests/e2e/settings.spec.ts (9 tests)
  • tests/e2e/transcoding.spec.ts (8 tests)

Problèmes :

  1. Aucun script de test dans package.json

    • Tests Playwright non exécutables via npm
    • Pas de test:e2e, test:unit, test:ci

  2. Tests dépendent de l'app web :

    • Pointent vers http://localhost:5173
    • Nécessitent l'app web running + auth fonctionnelle
    • Pas de mocks/stubs

  3. Scripts de test référencés mais inexistants :

    • scripts/production-tests.js appelle npm run test:unit, test:e2e, lighthouse:ci, test:perf, test:a11y
    • Aucun de ces scripts n'existe dans package.json

  4. Pas de tests unitaires :

    • Aucun test pour electron/main.ts
    • Aucun test pour electron/preload.ts
    • Pas de validation IPC, gestion d'erreurs, etc.

⚠️ Linter Status: NON CONFIGURÉ

  • Aucun linter configuré (ESLint, TSLint)
  • Aucun formatter (Prettier)
  • Aucun pre-commit hook

⚠️ Type Safety: PARTIEL

  • TypeScript configuré avec strict: true (OK)
  • Mais rootDir incorrect peut causer des problèmes
  • Pas de vérification de types dans CI

Security Findings

🔴 P0 — Vulnérabilités Critiques

1. Electron Version Vulnérable (CVE)

ID: MOD-P0-001
Fichier: package.json ligne 31
Version actuelle: electron@^25.0.0
Vulnérabilités :

  • GHSA-6r2x-8pq8-9489 : Heap Buffer Overflow in NativeImage (moderate)
  • GHSA-vmqv-hx8q-j7mg : ASAR Integrity Bypass via resource modification (moderate)

Impact :

  • RCE potentiel via images malveillantes
  • Bypass de l'intégrité ASAR (modification de fichiers packagés)

Fix minimal :

"electron": "^28.0.0"  // ou dernière LTS

Plan de validation :

npm audit
npm run build
npm run dist
# Tester sur Windows/macOS/Linux

Effort: S (1-2h)
Risque régression: Moyen (changements Electron majeurs possibles)

2. glob Package Vulnérable (Command Injection)

ID: MOD-P0-002
Fichier: package-lock.json (dépendance transitive)
Version: glob@10.2.0 - 10.4.5
Vulnérabilité: GHSA-5j98-mcp5-4vw2 — Command injection via -c/--cmd (high)

Impact :

  • RCE si glob est utilisé avec input utilisateur

Fix minimal :

npm audit fix

Plan de validation :

npm audit
npm run build

Effort: S (< 1h)
Risque régression: Faible

🟡 P1 — Sécurité Electron

3. DevTools Ouvert en Production (Risque)

ID: MOD-P1-001
Fichier: electron/main.ts ligne 41
Code :

if (isDev) {
    mainWindow.webContents.openDevTools();
}

Impact :

  • Si isDev est mal détecté, DevTools ouverts en prod
  • Accès console, injection de code, debug

Fix minimal :

if (isDev && process.env.ENABLE_DEVTOOLS === 'true') {
    mainWindow.webContents.openDevTools();
}

Plan de validation :

  • Build prod et vérifier que DevTools ne s'ouvrent pas
  • Test avec app.isPackaged === true

Effort: S (< 30min)
Risque régression: Faible

4. Pas de Validation d'URL avant loadURL

ID: MOD-P1-002
Fichier: electron/main.ts ligne 35-40
Code :

const WEB_URL = process.env.VITE_DEV_SERVER_URL || 'http://localhost:5173';
mainWindow.loadURL(WEB_URL).catch(e => {
    console.error('Failed to load local dev server. Is apps/web running?');
    console.error(e);
});

Impact :

  • Si VITE_DEV_SERVER_URL est modifié malicieusement, chargement d'URL arbitraire
  • SSRF potentiel (moins critique en desktop, mais mauvais pattern)

Fix minimal :

const WEB_URL = process.env.VITE_DEV_SERVER_URL || 'http://localhost:5173';
const ALLOWED_ORIGINS = ['http://localhost:5173', 'http://127.0.0.1:5173'];
if (!ALLOWED_ORIGINS.some(origin => WEB_URL.startsWith(origin))) {
    throw new Error(`Invalid dev server URL: ${WEB_URL}`);
}
mainWindow.loadURL(WEB_URL).catch(e => {
    // ...
});

Plan de validation :

  • Test avec VITE_DEV_SERVER_URL=http://evil.com
  • Vérifier que l'app refuse

Effort: S (< 1h)
Risque régression: Faible

5. Pas de CSP (Content Security Policy)

ID: MOD-P1-003
Fichier: electron/main.ts
Problème: Aucune CSP configurée dans session.defaultSession.webRequest.onHeadersReceived

Impact :

  • Injection de scripts possible depuis l'app web si compromise
  • XSS non mitigé au niveau Electron

Fix minimal :

import { session } from 'electron';

app.on('ready', () => {
    session.defaultSession.webRequest.onHeadersReceived((details, callback) => {
        callback({
            responseHeaders: {
                ...details.responseHeaders,
                'Content-Security-Policy': [
                    "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline';"
                ]
            }
        });
    });
    createWindow();
});

Plan de validation :

  • Test avec injection de script dans l'app web
  • Vérifier que CSP bloque

Effort: M (2-3h)
Risque régression: Moyen (peut casser certaines fonctionnalités web)

6. Preload Vide (Pas d'API Exposée)

ID: MOD-P1-004
Fichier: electron/preload.ts
Code : Vide (juste un commentaire)

Impact :

  • Pas de bridge sécurisé main ↔ renderer
  • Si besoin futur, risque d'utiliser nodeIntegration: true (dangereux)

Fix minimal :

import { contextBridge, ipcRenderer } from 'electron';

contextBridge.exposeInMainWorld('electronAPI', {
    platform: process.platform,
    versions: process.versions,
    // Exposer uniquement les APIs nécessaires
});

Plan de validation :

  • Test que window.electronAPI est disponible dans renderer
  • Vérifier que nodeIntegration: false est toujours respecté

Effort: S (< 1h)
Risque régression: Faible

🟢 P2 — Bonnes Pratiques

7. Pas de Gestion d'Erreurs Globale

ID: MOD-P2-001
Fichier: electron/main.ts
Problème: Pas de process.on('uncaughtException') ni process.on('unhandledRejection')

Impact :

  • Crashes silencieux
  • Pas de logging d'erreurs critiques

Fix minimal :

process.on('uncaughtException', (error) => {
    console.error('Uncaught Exception:', error);
    // Envoyer à Sentry si configuré
});

process.on('unhandledRejection', (reason, promise) => {
    console.error('Unhandled Rejection:', reason);
});

Effort: S (< 30min)
Risque régression: Faible

8. Pas de Validation de Fichier en Production

ID: MOD-P2-002
Fichier: electron/main.ts ligne 58
Code :

mainWindow.loadFile(path.join(__dirname, '../renderer/index.html'));

Impact :

  • Si fichier manquant, crash silencieux
  • Pas de fallback

Fix minimal :

import fs from 'fs';

const indexPath = path.join(__dirname, '../renderer/index.html');
if (!fs.existsSync(indexPath)) {
    dialog.showErrorBox(
        'Missing Files',
        'The application files are missing. Please reinstall the application.'
    );
    app.quit();
    return;
}
mainWindow.loadFile(indexPath);

Effort: S (< 1h)
Risque régression: Faible

Observability & Production Readiness

❌ Logs: NON STRUCTURÉS

Problèmes :

  • console.log/console.error uniquement
  • Pas de corrélation (request_id, trace_id)
  • Pas de niveaux log (info/warn/error)
  • Pas de rotation de logs
  • Pas d'intégration Sentry/LogRocket

Recommandation :

  • Utiliser electron-log ou winston
  • Structurer les logs (JSON)
  • Ajouter context (user_id, session_id)

❌ Metrics: AUCUNE

Manquant :

  • Pas de healthcheck endpoint (normal pour desktop, mais utile pour auto-update)
  • Pas de métriques de performance (FPS, memory, CPU)
  • Pas de crash reporting (Sentry)

Recommandation :

  • Intégrer Sentry pour crash reporting
  • Exposer métriques via IPC pour debug

⚠️ Healthchecks: PARTIEL

Présent :

  • Aucun healthcheck explicite

Manquant :

  • Vérification que l'app web répond avant de charger
  • Vérification de connectivité réseau (pour auto-update)

⚠️ Auto-Update: CONFIGURÉ MAIS NON TESTÉ

Présent :

  • electron-updater installé
  • Config GitHub dans package.json (ligne 95-98)

Manquant :

  • Pas de code d'auto-update dans main.ts
  • Pas de tests d'auto-update
  • Pas de rollback strategy

Recommandation :

import { autoUpdater } from 'electron-updater';

autoUpdater.checkForUpdatesAndNotify();
autoUpdater.on('update-available', () => {
    // Notifier l'utilisateur
});

❌ Error Handling: FAIBLE

Problèmes :

  • Pas de retry logic
  • Pas de circuit breaker
  • Pas de timeout sur loadURL
  • Erreurs silencieuses (catch sans action)

Exemple :

mainWindow.loadURL(WEB_URL).catch(e => {
    console.error('Failed to load local dev server. Is apps/web running?');
    console.error(e);
    // ❌ Pas de dialog utilisateur, pas de retry
});

Performance Notes

⚠️ Bundle Size: NON OPTIMISÉ

Problèmes :

  • Scripts d'optimisation présents (scripts/optimize-bundle.js) mais non utilisés
  • Pas de code splitting pour Electron (normal, mais à noter)
  • Pas d'analyse de bundle size

Recommandation :

  • Utiliser webpack-bundle-analyzer ou équivalent
  • Vérifier taille du bundle final

⚠️ Build Time: NON MESURÉ

  • Pas de métriques de build time
  • Pas d'optimisation de build (cache, parallélisation)

✅ Memory: OK (Wrapper Léger)

  • Wrapper minimal, pas de fuites évidentes
  • Mais pas de monitoring

⚠️ Startup Time: NON MESURÉ

  • Pas de métriques de temps de démarrage
  • Pas d'optimisation (lazy loading, etc.)

Issue List Priorisée (P0→P3)

🔴 P0 — Critiques (Do Immediately)

MOD-P0-001: Electron Version Vulnérable

  • Titre: Mettre à jour Electron vers version sécurisée
  • Impact: RCE potentiel, bypass ASAR
  • Preuve: package.json:31, npm audit
  • Cause: Version obsolète
  • Fix: npm install electron@^28.0.0
  • Validation: npm audit, build, tests E2E
  • Effet de bord: Possible breaking changes Electron
  • Effort: S (1-2h)

MOD-P0-002: glob Package Vulnérable

  • Titre: Mettre à jour glob (command injection)
  • Impact: RCE si utilisé avec input utilisateur
  • Preuve: npm audit (high severity)
  • Cause: Dépendance transitive vulnérable
  • Fix: npm audit fix
  • Validation: npm audit, build
  • Effet de bord: Faible
  • Effort: S (< 1h)

MOD-P0-003: Build Cassé (TypeScript)

  • Titre: Build échoue car tsc non trouvé
  • Impact: Impossible de build en production
  • Preuve: npm run build → tsc: command not found
  • Cause: TypeScript en devDependencies mais pas dans PATH
  • Fix: S'assurer que npm install est exécuté, ou utiliser npx tsc
  • Validation: npm run build doit réussir
  • Effet de bord: Aucun
  • Effort: S (< 30min)

MOD-P0-004: tsconfig.main.json rootDir Incorrect

  • Titre: rootDir pointe vers ./src mais fichiers dans ./electron/
  • Impact: Compilation incorrecte, fichiers non trouvés
  • Preuve: tsconfig.main.json:9 vs structure réelle
  • Cause: Incohérence de configuration
  • Fix: Changer rootDir: "./electron" ou "./"
  • Validation: npm run build, vérifier output
  • Effet de bord: Possible changement de structure dist/
  • Effort: S (< 30min)

🟡 P1 — Importants (Do This Sprint)

MOD-P1-001: DevTools Ouvert en Production

  • Titre: Risque d'ouverture DevTools en prod si isDev mal détecté
  • Impact: Debug console accessible, injection de code
  • Preuve: electron/main.ts:41
  • Cause: Détection isDev fragile
  • Fix: Ajouter flag explicite ENABLE_DEVTOOLS
  • Validation: Build prod, vérifier DevTools fermés
  • Effet de bord: Faible
  • Effort: S (< 30min)

MOD-P1-002: Pas de Validation d'URL

  • Titre: loadURL accepte n'importe quelle URL depuis env var
  • Impact: SSRF potentiel, chargement d'URL malveillante
  • Preuve: electron/main.ts:35-40
  • Cause: Pas de whitelist d'URLs
  • Fix: Whitelist localhost:5173 uniquement
  • Validation: Test avec URL malveillante
  • Effet de bord: Faible
  • Effort: S (< 1h)

MOD-P1-003: Pas de CSP

  • Titre: Content Security Policy manquante
  • Impact: XSS non mitigé au niveau Electron
  • Preuve: Aucune CSP dans main.ts
  • Cause: Non configuré
  • Fix: Ajouter CSP via session.webRequest
  • Validation: Test injection de script
  • Effet de bord: Peut casser certaines fonctionnalités web
  • Effort: M (2-3h)

MOD-P1-004: Preload Vide

  • Titre: Preload script vide, pas de bridge sécurisé
  • Impact: Risque futur d'utiliser nodeIntegration: true
  • Preuve: electron/preload.ts (vide)
  • Cause: Non implémenté
  • Fix: Exposer APIs via contextBridge
  • Validation: Test que window.electronAPI fonctionne
  • Effet de bord: Faible
  • Effort: S (< 1h)

MOD-P1-005: Scripts de Test Inexistants

  • Titre: Scripts référencés dans production-tests.js n'existent pas
  • Impact: Tests de production non exécutables
  • Preuve: scripts/production-tests.js:18-37 vs package.json
  • Cause: Scripts non ajoutés au package.json
  • Fix: Ajouter scripts manquants ou supprimer références
  • Validation: npm run prod:test doit fonctionner
  • Effet de bord: Aucun
  • Effort: S (< 1h)

MOD-P1-006: Pas de Tests Unitaires

  • Titre: Aucun test pour main.ts et preload.ts
  • Impact: Bugs non détectés, régressions possibles
  • Preuve: Aucun fichier de test dans tests/unit/
  • Cause: Tests non écrits
  • Fix: Ajouter tests unitaires (Jest/Vitest)
  • Validation: npm run test:unit doit passer
  • Effet de bord: Aucun
  • Effort: M (4-6h)

MOD-P1-007: Auto-Update Non Implémenté

  • Titre: electron-updater installé mais non utilisé
  • Impact: Pas de mise à jour automatique
  • Preuve: package.json:36 vs main.ts (aucun import)
  • Cause: Non implémenté
  • Fix: Implémenter auto-update avec notifications
  • Validation: Test avec serveur de mise à jour
  • Effet de bord: Moyen (nécessite serveur GitHub/autre)
  • Effort: M (4-6h)

🟢 P2 — Qualité (Do Next Sprint)

MOD-P2-001: Pas de Gestion d'Erreurs Globale

  • Titre: Pas de handlers pour uncaughtException/unhandledRejection
  • Impact: Crashes silencieux, pas de logging
  • Preuve: electron/main.ts (aucun handler)
  • Cause: Non implémenté
  • Fix: Ajouter handlers + Sentry
  • Effort: S (< 30min)

MOD-P2-002: Pas de Validation de Fichier en Production

  • Titre: loadFile ne vérifie pas l'existence du fichier
  • Impact: Crash si fichier manquant
  • Preuve: electron/main.ts:58
  • Cause: Pas de vérification
  • Fix: Vérifier existence + dialog erreur
  • Effort: S (< 1h)

MOD-P2-003: Pas de Linter/Formatter

  • Titre: Aucun ESLint/Prettier configuré
  • Impact: Code incohérent, bugs potentiels
  • Preuve: Aucun fichier de config
  • Cause: Non configuré
  • Fix: Ajouter ESLint + Prettier + pre-commit
  • Effort: M (2-3h)

MOD-P2-004: Logs Non Structurés

  • Titre: console.log uniquement, pas de logs structurés
  • Impact: Debug difficile, pas d'observabilité
  • Preuve: electron/main.ts (console.log partout)
  • Cause: Pas de logger configuré
  • Fix: Intégrer electron-log ou winston
  • Effort: M (2-3h)

MOD-P2-005: Pas de Healthcheck pour App Web

  • Titre: Charge l'app web sans vérifier qu'elle répond
  • Impact: Erreur silencieuse si app web down
  • Preuve: electron/main.ts:37 (catch sans action)
  • Cause: Pas de vérification
  • Fix: Healthcheck avant loadURL + retry
  • Effort: M (2-3h)

MOD-P2-006: Scripts de Déploiement Incomplets

  • Titre: deploy-production.js référence des commandes inexistantes
  • Impact: Déploiement impossible
  • Preuve: scripts/deploy-production.js:151,189 (build:optimized, deploy:staging, etc.)
  • Cause: Scripts non ajoutés au package.json
  • Fix: Ajouter scripts ou adapter deploy script
  • Effort: M (2-3h)

MOD-P2-007: Pas de Documentation de Build

  • Titre: README ne documente pas le processus de build complet
  • Impact: Développeurs perdus, build manuel
  • Preuve: README.md (section build incomplète)
  • Cause: Documentation incomplète
  • Fix: Documenter build + copie de fichiers
  • Effort: S (< 1h)

MOD-P2-008: Pas de CI/CD Config

  • Titre: Aucun fichier GitHub Actions / GitLab CI
  • Impact: Pas de build/test automatique
  • Preuve: Aucun fichier .github/workflows/ ou .gitlab-ci.yml
  • Cause: Non configuré
  • Fix: Ajouter CI/CD (build, test, audit)
  • Effort: M (3-4h)

🔵 P3 — Cosmétique (Nice to Have)

MOD-P3-001: Icons Non Vérifiés

  • Titre: Assets d'icons référencés mais non vérifiés
  • Impact: Build peut échouer si icons manquants
  • Preuve: package.json:51,63,74 (assets/icon.*)
  • Cause: Non vérifié
  • Fix: Vérifier existence ou générer icons
  • Effort: S (< 1h)

MOD-P3-002: Pas de Source Maps en Production

  • Titre: Source maps générées mais peut-être non utilisées
  • Impact: Debug production difficile
  • Preuve: tsconfig.main.json:17 (sourceMap: true)
  • Cause: Non vérifié
  • Fix: Vérifier utilisation ou désactiver
  • Effort: S (< 30min)

MOD-P3-003: Pas de Métriques de Performance

  • Titre: Pas de monitoring de performance (FPS, memory, CPU)
  • Impact: Pas d'optimisation basée sur données
  • Preuve: Aucun code de monitoring
  • Cause: Non implémenté
  • Fix: Ajouter monitoring (optionnel)
  • Effort: M (4-6h)

MOD-P3-004: Scripts d'Optimisation Non Utilisés

  • Titre: optimize-bundle.js existe mais non intégré
  • Impact: Bundle non optimisé
  • Preuve: scripts/optimize-bundle.js (non appelé)
  • Cause: Script standalone
  • Fix: Intégrer dans build ou supprimer
  • Effort: S (< 1h)

MOD-P3-005: validate-frontend-complete.sh Obsolète

  • Titre: Script référence des fichiers qui n'existent pas dans ce module
  • Impact: Confusion, script inutile
  • Preuve: validate-frontend-complete.sh (vérifie src/features/*)
  • Cause: Script copié depuis autre module
  • Fix: Adapter ou supprimer
  • Effort: S (< 30min)

Execution Plan

Checklist P0 (Ordre Strict)

  1. ✅ MOD-P0-002: npm audit fix (glob)
  2. ✅ MOD-P0-001: npm install electron@^28.0.0 + tests
  3. ✅ MOD-P0-004: Corriger tsconfig.main.json rootDir
  4. ✅ MOD-P0-003: Vérifier build fonctionne (npm install + npm run build)
  5. ✅ Validation: npm audit, npm run build, npm run dist (test packaging)

Temps estimé: 2-3h

Checklist P1 (Par Lots Cohérents)

Lot 1: Sécurité Electron (2-3h)

  1. MOD-P1-001: DevTools conditionnel
  2. MOD-P1-002: Validation URL
  3. MOD-P1-003: CSP (optionnel, peut être P2)

Lot 2: Tests & Qualité (6-8h)

  1. MOD-P1-005: Ajouter scripts de test manquants
  2. MOD-P1-006: Tests unitaires (main.ts, preload.ts)
  3. MOD-P2-003: Linter/Formatter

Lot 3: Auto-Update & Observabilité (6-8h)

  1. MOD-P1-007: Implémenter auto-update
  2. MOD-P2-001: Gestion d'erreurs globale
  3. MOD-P2-004: Logs structurés

Lot 4: Robustesse (4-6h)

  1. MOD-P1-004: Preload avec contextBridge
  2. MOD-P2-002: Validation fichier production
  3. MOD-P2-005: Healthcheck app web

Temps estimé total P1: 18-25h

Quick Wins (≤ 1h chacun)

  1. MOD-P2-007: Documenter build process (30min)
  2. MOD-P3-001: Vérifier icons (30min)
  3. MOD-P3-004: Intégrer ou supprimer optimize-bundle.js (1h)
  4. MOD-P3-005: Adapter/supprimer validate-frontend-complete.sh (30min)
  5. MOD-P2-006: Corriger scripts de déploiement (1h)

Tests à Ajouter en Priorité

  1. Tests unitaires (P1):

    • electron/main.ts: createWindow, gestion erreurs
    • electron/preload.ts: contextBridge APIs
    • Mock Electron APIs (sinon)

  2. Tests E2E (déjà présents mais à améliorer):

    • Tester build production
    • Tester auto-update (mock)
    • Tester gestion d'erreurs

  3. Tests d'intégration:

    • Build + package (Windows/macOS/Linux)
    • Vérifier que l'app web se charge correctement

PR Plan

PR 1: Fix P0 (Sécurité & Build)

Titre: fix: Update Electron, fix build, add security validations
Fichiers:

  • package.json (Electron update)
  • tsconfig.main.json (rootDir fix)
  • electron/main.ts (URL validation, DevTools fix)
  • package-lock.json (audit fix)

Tests: Build, audit, dist

PR 2: Tests & Qualité

Titre: feat: Add unit tests, linter, and test scripts
Fichiers:

  • package.json (scripts de test)
  • tests/unit/main.test.ts (nouveau)
  • tests/unit/preload.test.ts (nouveau)
  • .eslintrc.js (nouveau)
  • .prettierrc (nouveau)

Tests: npm run test:unit, npm run lint

PR 3: Preload & CSP

Titre: feat: Implement preload bridge and CSP
Fichiers:

  • electron/preload.ts (contextBridge)
  • electron/main.ts (CSP)

Tests: E2E, vérifier window.electronAPI

PR 4: Auto-Update

Titre: feat: Implement auto-update with electron-updater
Fichiers:

  • electron/main.ts (auto-update logic)
  • electron/updater.ts (nouveau, optionnel)

Tests: Mock serveur de mise à jour

PR 5: Observabilité

Titre: feat: Add structured logging and error handling
Fichiers:

  • electron/main.ts (error handlers)
  • electron/logger.ts (nouveau)
  • package.json (electron-log)

Tests: Vérifier logs structurés

PR 6: Robustesse

Titre: feat: Add file validation and healthcheck
Fichiers:

  • electron/main.ts (file validation, healthcheck)

Tests: Test avec fichier manquant

PR 7: CI/CD

Titre: ci: Add GitHub Actions workflow
Fichiers:

  • .github/workflows/ci.yml (nouveau)

Tests: Vérifier que CI passe

PR 8: Documentation & Cleanup

Titre: docs: Update README and cleanup scripts
Fichiers:

  • README.md (build process)
  • scripts/ (cleanup ou intégration)

Résumé Exécutif

Statut Global: ⚠️ NON PRODUCTION READY

Problèmes critiques :

  • 🔴 4 P0 (sécurité, build cassé)
  • 🟡 7 P1 (sécurité Electron, tests, auto-update)
  • 🟢 8 P2 (qualité, observabilité)
  • 🔵 5 P3 (cosmétique)

Actions Immédiates

  1. Mettre à jour Electron (P0-001)
  2. Fixer le build (P0-003, P0-004)
  3. Ajouter validation URL (P1-002)
  4. Ajouter tests unitaires (P1-006)

Estimation Totale

  • P0: 2-3h
  • P1: 18-25h
  • P2: 12-18h
  • P3: 4-6h

Total: ~36-52h de travail

Risques Majeurs

  1. Sécurité: Electron vulnérable, pas de CSP, validation URL manquante
  2. Build: Build cassé, configuration incohérente
  3. Tests: Pas de tests unitaires, scripts manquants
  4. Production: Pas d'auto-update, pas d'observabilité, gestion d'erreurs faible

Fin du rapport d'audit