samre-cli 1.0.0

package/README.md

@@ -0,0 +1,46 @@
+# samre-cli
+
+> CLI officiel d'injection automatique du SDK **Samré** pour les applications mobiles (Flutter & React Native).
+
+Permet aux développeurs de connecter instantanément leur application mobile à la plateforme **Samré** pour mener à bien leurs campagnes de test fermé Google Play (12 jours, 12 panélistes).
+
+---
+
+## 🚀 Utilisation Rapide
+
+Aucune installation préalable n'est nécessaire. Exécutez simplement `npx` dans le répertoire racine de votre projet mobile :
+
+### 1. Injection automatique du SDK
+```bash
+npx samre-cli inject --token=VOTRE_TOKEN_INTEGRATION
+```
+
+Si votre serveur Samré est hébergé sur une URL personnalisée ou un tunnel (ngrok) :
+```bash
+npx samre-cli inject --token=VOTRE_TOKEN_INTEGRATION --api-url=https://mon-serveur-samre.com
+```
+
+### 2. Tester votre application
+```bash
+flutter run
+```
+Un badge discret de test apparaîtra sur votre écran. Après 25 secondes d'activité, vos panélistes pourront soumettre leur code quotidien en un clic.
+
+### 3. Désinstallation post-campagne
+Une fois vos 12 jours de test terminés :
+```bash
+npx samre-cli remove
+```
+Restaure votre application dans son état d'origine en supprimant le SDK sans laisser aucun résidu.
+
+---
+
+## 🔒 Sécurité & Confidentialité
+- Les clés HMAC secrètes ne quittent jamais le backend Samré.
+- Les validations sont sécurisées contre le rejeu et les fraudes.
+- Aucun impact sur les performances de votre application.
+
+---
+
+## 📄 Licence
+MIT © [Samré Team](https://samre.app)

package/bin/samre.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+import { handleInject } from '../src/commands/inject.js';
+import { handleRemove } from '../src/commands/remove.js';
+import { logger } from '../src/utils/logger.js';
+
+function parseArgs(args) {
+  const result = {
+    command: null,
+    token: null,
+    apiUrl: 'http://localhost:8000',
+    help: false,
+    version: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === 'inject' || arg === 'remove') {
+      result.command = arg;
+    } else if (arg === '--help' || arg === '-h') {
+      result.help = true;
+    } else if (arg === '--version' || arg === '-v') {
+      result.version = true;
+    } else if (arg.startsWith('--token=')) {
+      result.token = arg.slice(8);
+    } else if (arg === '--token' && i + 1 < args.length) {
+      result.token = args[++i];
+    } else if (arg.startsWith('--api-url=')) {
+      result.apiUrl = arg.slice(10);
+    } else if (arg === '--api-url' && i + 1 < args.length) {
+      result.apiUrl = args[++i];
+    }
+  }
+
+  return result;
+}
+
+function showHelp() {
+  logger.banner();
+  console.log(`  ${"\x1b[1m"}Usage:${"\x1b[0m"}
+    npx samre-cli <commande> [options]
+
+  ${"\x1b[1m"}Commandes:${"\x1b[0m"}
+    inject               Injecte automatiquement le SDK Samré dans votre projet Flutter
+    remove               Désinstalle proprement le SDK et restaure les fichiers d'origine
+
+  ${"\x1b[1m"}Options pour inject :${"\x1b[0m"}
+    --token=<TOKEN>      Token unique d'intégration de votre application (Requis)
+    --api-url=<URL>      URL de l'API Samré (Optionnel, ex: https://votredomaine.com ou ngrok)
+
+  ${"\x1b[1m"}Options générales :${"\x1b[0m"}
+    --help, -h           Affiche cette aide
+    --version, -v        Affiche la version du CLI
+
+  ${"\x1b[1m"}Exemples :${"\x1b[0m"}
+    npx samre-cli inject --token=integ_a1b2c3d4e5f6
+    npx samre-cli inject --token=integ_a1b2c3d4e5f6 --api-url=https://mon-serveur.com
+    npx samre-cli remove
+`);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+
+  if (options.version) {
+    console.log('samre-cli v1.0.0');
+    process.exit(0);
+  }
+
+  if (options.help || !options.command) {
+    showHelp();
+    process.exit(0);
+  }
+
+  try {
+    if (options.command === 'inject') {
+      await handleInject(options);
+    } else if (options.command === 'remove') {
+      await handleRemove(options);
+    }
+  } catch (err) {
+    logger.error(`Erreur inattendue : ${err.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "samre-cli",
+  "version": "1.0.0",
+  "description": "CLI officiel d'injection automatique du SDK Samré dans les applications mobiles (Flutter, React Native)",
+  "main": "bin/samre.js",
+  "bin": {
+    "samre-cli": "bin/samre.js",
+    "samre": "bin/samre.js"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "test": "node bin/samre.js --help"
+  },
+  "keywords": [
+    "samre",
+    "samre-sdk",
+    "flutter",
+    "react-native",
+    "testing",
+    "google-play",
+    "closed-testing",
+    "daily-code"
+  ],
+  "author": "Samré Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lydiedouti09-crypto/samre-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lydiedouti09-crypto/samre-cli/issues"
+  },
+  "homepage": "https://samre.app"
+}

package/src/commands/inject.js

@@ -0,0 +1,92 @@
+import { logger } from '../utils/logger.js';
+import { fetchIntegrationInfo } from '../utils/api.js';
+import { FlutterUtil } from '../utils/flutter.js';
+
+export async function handleInject(options) {
+  const { token, apiUrl = 'http://localhost:8000', cwd = process.cwd() } = options;
+
+  if (!token) {
+    logger.error("Le paramètre --token est requis pour l'injection.");
+    console.log("  Usage : npx samre-cli inject --token=<VOTRE_TOKEN> [--api-url=<URL>]\n");
+    process.exit(1);
+  }
+
+  logger.banner();
+  logger.info(`Récupération de la configuration pour le token : ${token}...`);
+  logger.info(`Serveur Samré cible : ${apiUrl}`);
+
+  // 1. Récupération des informations d'intégration depuis l'API
+  let appData;
+  let normalizedUrl;
+  try {
+    const res = await fetchIntegrationInfo(apiUrl, token);
+    appData = res.data;
+    normalizedUrl = res.normalizedApiUrl;
+    logger.success(`Application identifiée : "${appData.application.nom}" (v${appData.application.version})`);
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+
+  // 2. Détection du type de projet
+  const isFlutter = FlutterUtil.isFlutterProject(cwd);
+
+  if (!isFlutter) {
+    logger.error("Aucun projet Flutter détecté dans le répertoire courant (pubspec.yaml introuvable).");
+    logger.info("Assurez-vous d'exécuter cette commande à la racine de votre projet mobile.");
+    process.exit(1);
+  }
+
+  logger.step('1/3', 'Configuration des dépendances...');
+  try {
+    const depRes = FlutterUtil.ensureHttpDependency(cwd);
+    if (depRes.alreadyPresent) {
+      logger.info('Dépendance "http" déjà présente dans pubspec.yaml');
+    } else {
+      logger.success('Dépendance "http: ^1.2.0" ajoutée avec succès');
+    }
+  } catch (err) {
+    logger.warn(`Attention lors de l'ajout de dépendance : ${err.message}`);
+  }
+
+  logger.step('2/3', 'Génération du SDK Samré Flutter...');
+  try {
+    const sdkPath = FlutterUtil.writeSdkFile(cwd, {
+      apiUrl: normalizedUrl,
+      apiKey: appData.apiKey,
+      appId: appData.application.id,
+      appName: appData.application.nom,
+      dureeJours: appData.application.dureeJours,
+    });
+    logger.success(`Fichier créé : ${sdkPath}`);
+  } catch (err) {
+    logger.error(`Échec de création du SDK : ${err.message}`);
+    process.exit(1);
+  }
+
+  logger.step('3/3', "Activation de l'Overlay Samré...");
+  try {
+    const mainRes = FlutterUtil.injectIntoMain(cwd);
+    if (mainRes.alreadyInjected) {
+      logger.info("SamreOverlay est déjà activé dans lib/main.dart");
+    } else if (mainRes.modifiedHome) {
+      logger.success("SamreOverlay a été automatiquement branché sur votre écran d'accueil !");
+      logger.info(`Sauvegarde de sécurité créée sous : lib/main.dart.samre_bak`);
+    } else {
+      logger.success("Import ajouté dans lib/main.dart.");
+      logger.info("Pour finaliser, entourez votre écran d'accueil avec SamreOverlay :");
+      logger.code("home: const SamreOverlay(\n  child: MyHomePage(),\n)");
+    }
+  } catch (err) {
+    logger.warn(`Note sur main.dart : ${err.message}`);
+  }
+
+  console.log('\n' + '─'.repeat(60));
+  logger.success("🎉 Intégration du SDK Samré terminée avec succès !");
+  console.log('─'.repeat(60));
+  console.log('\n  👉 Prochaine étape : Lancez votre application pour tester :');
+  logger.code('flutter run');
+  console.log('  👉 Pour désinstaller proprement après votre campagne :');
+  logger.code('npx samre-cli remove');
+  console.log('');
+}

package/src/commands/remove.js

@@ -0,0 +1,32 @@
+import { logger } from '../utils/logger.js';
+import { FlutterUtil } from '../utils/flutter.js';
+
+export async function handleRemove(options) {
+  const { cwd = process.cwd() } = options;
+
+  logger.banner();
+  logger.info("Désinstallation du SDK Samré...");
+
+  const isFlutter = FlutterUtil.isFlutterProject(cwd);
+
+  if (!isFlutter) {
+    logger.error("Aucun projet Flutter détecté dans le répertoire courant (pubspec.yaml introuvable).");
+    process.exit(1);
+  }
+
+  const { sdkDeleted, mainRestored } = FlutterUtil.removeSdk(cwd);
+
+  if (sdkDeleted) {
+    logger.success("Fichier lib/samre_sdk.dart supprimé.");
+  } else {
+    logger.info("Fichier lib/samre_sdk.dart déjà absent.");
+  }
+
+  if (mainRestored) {
+    logger.success("Fichier lib/main.dart restauré dans son état initial.");
+  }
+
+  console.log('\n' + '─'.repeat(60));
+  logger.success("✨ Désinstallation propre terminée sans résidu !");
+  console.log('─'.repeat(60) + '\n');
+}

package/src/templates/flutter_sdk.js

@@ -0,0 +1,303 @@
+// Modèle complet pour lib/samre_sdk.dart
+
+export function generateFlutterSdkCode({ apiUrl, apiKey, appId, appName, dureeJours }) {
+  return `// =================================================================
+// SDK Samré Mobile pour Flutter (Généré automatiquement par samre-cli)
+// Application : ${appName || 'App Samré'} (ID: ${appId})
+// Campagne : ${dureeJours || 12} jours
+// =================================================================
+
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+import 'package:flutter/material.dart';
+import 'package:http/http.dart' as http;
+
+/// Configuration du SDK Samré
+class SamreConfig {
+  static const String apiUrl = "${apiUrl}";
+  static const String apiKey = "${apiKey}";
+  static const String appId = "${appId}";
+  static const int requiredDurationSeconds = 25; // Compteur de sécurité anti-triche
+}
+
+/// Overlay automatique avec compteur de sécurité de 25 secondes
+class SamreOverlay extends StatefulWidget {
+  final Widget child;
+  const SamreOverlay({Key? key, required this.child}) : super(key: key);
+
+  @override
+  State<SamreOverlay> createState() => _SamreOverlayState();
+}
+
+class _SamreOverlayState extends State<SamreOverlay> {
+  int _secondsRemaining = SamreConfig.requiredDurationSeconds;
+  bool _canSubmit = false;
+  Timer? _timer;
+
+  @override
+  void initState() {
+    super.initState();
+    _startTimer();
+  }
+
+  void _startTimer() {
+    _timer = Timer.periodic(const Duration(seconds: 1), (timer) {
+      if (!mounted) return;
+      if (_secondsRemaining > 1) {
+        setState(() => _secondsRemaining--);
+      } else {
+        setState(() {
+          _secondsRemaining = 0;
+          _canSubmit = true;
+        });
+        timer.cancel();
+      }
+    });
+  }
+
+  @override
+  void dispose() {
+    _timer?.cancel();
+    super.dispose();
+  }
+
+  void _openValidationDialog() {
+    showDialog(
+      context: context,
+      barrierDismissible: false,
+      builder: (ctx) => const SamreValidationDialog(),
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Stack(
+      children: [
+        widget.child,
+        Positioned(
+          bottom: 24,
+          right: 20,
+          child: Material(
+            elevation: 8,
+            borderRadius: BorderRadius.circular(24),
+            color: _canSubmit ? const Color(0xFF2563EB) : Colors.black.withOpacity(0.75),
+            child: InkWell(
+              borderRadius: BorderRadius.circular(24),
+              onTap: _canSubmit ? _openValidationDialog : null,
+              child: Padding(
+                padding: const EdgeInsets.symmetric(horizontal: 14, vertical: 10),
+                child: Row(
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    Icon(
+                      _canSubmit ? Icons.verified_user : Icons.timer_outlined,
+                      color: Colors.white,
+                      size: 18,
+                    ),
+                    const SizedBox(width: 8),
+                    Text(
+                      _canSubmit ? 'Valider Journée' : 'Test en cours (\${_secondsRemaining}s)',
+                      style: const TextStyle(
+                        color: Colors.white,
+                        fontWeight: FontWeight.bold,
+                        fontSize: 12,
+                        decoration: TextDecoration.none,
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+        ),
+      ],
+    );
+  }
+}
+
+/// Boîte de dialogue de validation du code quotidien par le panéliste
+class SamreValidationDialog extends StatefulWidget {
+  const SamreValidationDialog({Key? key}) : super(key: key);
+
+  @override
+  State<SamreValidationDialog> createState() => _SamreValidationDialogState();
+}
+
+class _SamreValidationDialogState extends State<SamreValidationDialog> {
+  final _panelisteCtrl = TextEditingController();
+  final _codeCtrl = TextEditingController();
+  bool _loading = false;
+  String? _message;
+  bool _success = false;
+
+  @override
+  void dispose() {
+    _panelisteCtrl.dispose();
+    _codeCtrl.dispose();
+    super.dispose();
+  }
+
+  Future<void> _verify() async {
+    final paneliste = _panelisteCtrl.text.trim();
+    final code = _codeCtrl.text.trim();
+
+    if (paneliste.isEmpty || code.isEmpty) {
+      setState(() {
+        _message = 'Veuillez renseigner votre ID panéliste et le code du jour.';
+        _success = false;
+      });
+      return;
+    }
+
+    setState(() {
+      _loading = true;
+      _message = null;
+    });
+
+    try {
+      final uri = Uri.parse('\${SamreConfig.apiUrl}/api/sdk/verify-day');
+      final response = await http.post(
+        uri,
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json',
+          'X-App-Key': SamreConfig.apiKey,
+        },
+        body: jsonEncode({
+          'apiKey': SamreConfig.apiKey,
+          'app_id': SamreConfig.appId,
+          'panelisteId': paneliste,
+          'panelisteUid': paneliste,
+          'code': code,
+          'deviceId': Platform.isAndroid ? 'android-\${paneliste}' : 'ios-\${paneliste}',
+        }),
+      ).timeout(const Duration(seconds: 15));
+
+      final data = jsonDecode(response.body);
+
+      if (response.statusCode >= 200 && response.statusCode < 300 && data['success'] == true) {
+        setState(() {
+          _success = true;
+          _message = data['message'] ?? 'Félicitations ! Votre journée de test a été validée avec succès.';
+        });
+      } else {
+        setState(() {
+          _success = false;
+          _message = data['message'] ?? data['error'] ?? 'Code invalide ou expiré.';
+        });
+      }
+    } catch (e) {
+      setState(() {
+        _success = false;
+        _message = 'Erreur de connexion au serveur Samré. Vérifiez votre connexion internet.';
+      });
+    } finally {
+      setState(() => _loading = false);
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return AlertDialog(
+      backgroundColor: const Color(0xFF0F172A),
+      shape: RoundedRectangleBorder(
+        borderRadius: BorderRadius.circular(20),
+        side: const BorderSide(color: Color(0xFF334155)),
+      ),
+      title: Row(
+        children: [
+          Container(
+            padding: const EdgeInsets.all(8),
+            decoration: BoxDecoration(
+              color: const Color(0xFF2563EB).withOpacity(0.2),
+              borderRadius: BorderRadius.circular(10),
+            ),
+            child: const Icon(Icons.verified, color: Color(0xFF60A5FA), size: 22),
+          ),
+          const SizedBox(width: 12),
+          const Expanded(
+            child: Text(
+              'Validation Samré',
+              style: TextStyle(color: Colors.white, fontSize: 18, fontWeight: FontWeight.bold),
+            ),
+          ),
+        ],
+      ),
+      content: SingleChildScrollView(
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.stretch,
+          children: [
+            const Text(
+              'Saisissez vos identifiants fournis par la plateforme Samré pour enregistrer votre journée.',
+              style: TextStyle(color: Color(0xFF94A3B8), fontSize: 13),
+            ),
+            const SizedBox(height: 16),
+            TextField(
+              controller: _panelisteCtrl,
+              style: const TextStyle(color: Colors.white, fontWeight: FontWeight.w600),
+              decoration: InputDecoration(
+                labelText: 'Identifiant Panéliste',
+                labelStyle: const TextStyle(color: Color(0xFF94A3B8)),
+                hintText: 'Ex: TST-7A8B9C',
+                hintStyle: const TextStyle(color: Color(0xFF475569)),
+                filled: true,
+                fillColor: const Color(0xFF1E293B),
+                border: OutlineInputBorder(borderRadius: BorderRadius.circular(12)),
+              ),
+            ),
+            const SizedBox(height: 12),
+            TextField(
+              controller: _codeCtrl,
+              textCapitalization: TextCapitalization.characters,
+              style: const TextStyle(color: Colors.white, letterSpacing: 2, fontWeight: FontWeight.bold),
+              decoration: InputDecoration(
+                labelText: 'Code Unique du Jour',
+                labelStyle: const TextStyle(color: Color(0xFF94A3B8)),
+                hintText: 'Ex: 7K9P-4MX2',
+                hintStyle: const TextStyle(color: Color(0xFF475569), letterSpacing: 0),
+                filled: true,
+                fillColor: const Color(0xFF1E293B),
+                border: OutlineInputBorder(borderRadius: BorderRadius.circular(12)),
+              ),
+            ),
+            if (_message != null) ...[
+              const SizedBox(height: 14),
+              Container(
+                padding: const EdgeInsets.all(12),
+                decoration: BoxDecoration(
+                  color: _success ? const Color(0xFF065F46).withOpacity(0.3) : const Color(0xFF991B1B).withOpacity(0.3),
+                  borderRadius: BorderRadius.circular(10),
+                  border: Border.all(color: _success ? const Color(0xFF10B981) : const Color(0xFFEF4444)),
+                ),
+                child: Text(
+                  _message!,
+                  style: TextStyle(color: _success ? const Color(0xFF34D399) : const Color(0xFFF87171), fontSize: 12, fontWeight: FontWeight.w600),
+                ),
+              ),
+            ],
+          ],
+        ),
+      ),
+      actions: [
+        TextButton(
+          onPressed: () => Navigator.pop(context),
+          child: const Text('Fermer', style: TextStyle(color: Color(0xFF94A3B8))),
+        ),
+        ElevatedButton(
+          onPressed: _loading ? null : _verify,
+          style: ElevatedButton.styleFrom(
+            backgroundColor: const Color(0xFF2563EB),
+            shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(10)),
+          ),
+          child: _loading
+              ? const SizedBox(width: 16, height: 16, child: CircularProgressIndicator(color: Colors.white, strokeWidth: 2))
+              : const Text('Valider', style: TextStyle(color: Colors.white, fontWeight: FontWeight.bold)),
+        ),
+      ],
+    );
+  }
+}
+`;
+}

package/src/utils/api.js

@@ -0,0 +1,41 @@
+// Récupération des informations d'intégration depuis l'API Samré
+
+export async function fetchIntegrationInfo(apiUrl, token) {
+  // Normaliser l'URL
+  let baseUrl = apiUrl.trim();
+  if (baseUrl.endsWith('/')) {
+    baseUrl = baseUrl.slice(0, -1);
+  }
+
+  const endpoint = `${baseUrl}/api/public/integration/${encodeURIComponent(token)}`;
+
+  try {
+    const response = await fetch(endpoint, {
+      method: 'GET',
+      headers: {
+        'Accept': 'application/json',
+        'User-Agent': 'samre-cli/1.0.0'
+      }
+    });
+
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error(`Token d'intégration invalide ou introuvable : "${token}"`);
+      }
+      const errText = await response.text();
+      throw new Error(`Erreur serveur (${response.status}) : ${errText || response.statusText}`);
+    }
+
+    const data = await response.json();
+    return {
+      success: true,
+      data,
+      normalizedApiUrl: baseUrl
+    };
+  } catch (err) {
+    if (err.cause && err.cause.code === 'ECONNREFUSED') {
+      throw new Error(`Impossible de joindre le serveur Samré sur "${baseUrl}". Vérifiez que l'API ou le tunnel ngrok est actif.`);
+    }
+    throw err;
+  }
+}

package/src/utils/flutter.js

@@ -0,0 +1,131 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { generateFlutterSdkCode } from '../templates/flutter_sdk.js';
+
+export const FlutterUtil = {
+  isFlutterProject(cwd = process.cwd()) {
+    const pubspecPath = path.join(cwd, 'pubspec.yaml');
+    return fs.existsSync(pubspecPath);
+  },
+
+  ensureHttpDependency(cwd = process.cwd()) {
+    const pubspecPath = path.join(cwd, 'pubspec.yaml');
+    if (!fs.existsSync(pubspecPath)) {
+      throw new Error("pubspec.yaml introuvable.");
+    }
+
+    let pubspecContent = fs.readFileSync(pubspecPath, 'utf-8');
+
+    // Vérifier si http est déjà présent
+    if (pubspecContent.includes('http:') || pubspecContent.includes('http :')) {
+      return { alreadyPresent: true };
+    }
+
+    // Essayer avec flutter pub add http si possible
+    try {
+      execSync('flutter pub add http', { cwd, stdio: 'ignore' });
+      return { addedViaCli: true };
+    } catch {
+      // Fallback : injection directe dans pubspec.yaml
+      const lines = pubspecContent.split('\n');
+      const depIndex = lines.findIndex(l => /^dependencies\s*:/.test(l));
+
+      if (depIndex === -1) {
+        throw new Error("Section 'dependencies:' introuvable dans pubspec.yaml");
+      }
+
+      // Insérer http: ^1.2.0 juste après 'dependencies:'
+      lines.splice(depIndex + 1, 0, '  http: ^1.2.0');
+      fs.writeFileSync(pubspecPath, lines.join('\n'), 'utf-8');
+      return { addedDirectly: true };
+    }
+  },
+
+  writeSdkFile(cwd = process.cwd(), config) {
+    const libDir = path.join(cwd, 'lib');
+    if (!fs.existsSync(libDir)) {
+      fs.mkdirSync(libDir, { recursive: true });
+    }
+
+    const sdkPath = path.join(libDir, 'samre_sdk.dart');
+    const sdkCode = generateFlutterSdkCode(config);
+    fs.writeFileSync(sdkPath, sdkCode, 'utf-8');
+    return sdkPath;
+  },
+
+  injectIntoMain(cwd = process.cwd()) {
+    const mainPath = path.join(cwd, 'lib', 'main.dart');
+    const backupPath = path.join(cwd, 'lib', 'main.dart.samre_bak');
+
+    if (!fs.existsSync(mainPath)) {
+      return { injected: false, reason: 'main.dart introuvable' };
+    }
+
+    const content = fs.readFileSync(mainPath, 'utf-8');
+
+    // Sauvegarde de secours si pas encore existante
+    if (!fs.existsSync(backupPath)) {
+      fs.writeFileSync(backupPath, content, 'utf-8');
+    }
+
+    // Si déjà injecté
+    if (content.includes('SamreOverlay') || content.includes('samre_sdk.dart')) {
+      return { injected: true, alreadyInjected: true, backupPath };
+    }
+
+    let modified = content;
+
+    // 1. Ajouter l'import en haut
+    const importStatement = "import 'package:flutter/material.dart';\nimport 'samre_sdk.dart';\n";
+    if (!modified.includes('samre_sdk.dart')) {
+      modified = importStatement + modified;
+    }
+
+    // 2. Tenter d'envelopper builder ou home dans MaterialApp
+    // Exemple de pattern courant : home: QuelqueChose() -> home: SamreOverlay(child: QuelqueChose())
+    const homeRegex = /home\s*:\s*([^,\n\);]+)/;
+    if (homeRegex.test(modified) && !modified.includes('SamreOverlay')) {
+      modified = modified.replace(homeRegex, (match, p1) => {
+        return `home: SamreOverlay(child: ${p1.trim()})`;
+      });
+      fs.writeFileSync(mainPath, modified, 'utf-8');
+      return { injected: true, modifiedHome: true, backupPath };
+    }
+
+    // Si injection automatique du widget home n'a pas pu matcher le pattern exact,
+    // on sauvegarde le fichier avec l'import et on informe le dev
+    fs.writeFileSync(mainPath, modified, 'utf-8');
+    return { injected: false, importAdded: true, backupPath };
+  },
+
+  removeSdk(cwd = process.cwd()) {
+    const libDir = path.join(cwd, 'lib');
+    const sdkPath = path.join(libDir, 'samre_sdk.dart');
+    const mainPath = path.join(libDir, 'main.dart');
+    const backupPath = path.join(libDir, 'main.dart.samre_bak');
+
+    let sdkDeleted = false;
+    let mainRestored = false;
+
+    if (fs.existsSync(sdkPath)) {
+      fs.unlinkSync(sdkPath);
+      sdkDeleted = true;
+    }
+
+    if (fs.existsSync(backupPath)) {
+      fs.copyFileSync(backupPath, mainPath);
+      fs.unlinkSync(backupPath);
+      mainRestored = true;
+    } else if (fs.existsSync(mainPath)) {
+      // Nettoyage manuel si pas de backup
+      let content = fs.readFileSync(mainPath, 'utf-8');
+      content = content.replace(/import\s+['"]samre_sdk\.dart['"];\s*\n?/g, '');
+      content = content.replace(/SamreOverlay\s*\(\s*child\s*:\s*([^)]+)\)/g, '$1');
+      fs.writeFileSync(mainPath, content, 'utf-8');
+      mainRestored = true;
+    }
+
+    return { sdkDeleted, mainRestored };
+  }
+};

package/src/utils/logger.js

@@ -0,0 +1,62 @@
+// Utilitaires de log stylisé pour le terminal avec codes de couleurs ANSI
+
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  
+  // Couleurs de texte
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+  
+  // Arrière-plans
+  bgBlue: '\x1b[44m',
+  bgGreen: '\x1b[42m',
+};
+
+export const logger = {
+  banner() {
+    console.log('');
+    console.log(`  ${colors.bright}${colors.cyan}███████╗ █████╗ ███╗   ███╗██████╗ ███████╗${colors.reset}`);
+    console.log(`  ${colors.bright}${colors.cyan}██╔════╝██╔══██╗████╗ ████║██╔══██╗██╔════╝${colors.reset}`);
+    console.log(`  ${colors.bright}${colors.blue}███████╗███████║██╔████╔██║██████╔╝█████╗  ${colors.reset}`);
+    console.log(`  ${colors.bright}${colors.blue}╚════██║██╔══██║██║╚██╔╝██║██╔══██╗██╔══╝  ${colors.reset}`);
+    console.log(`  ${colors.bright}${colors.magenta}███████║██║  ██║██║ ╚═╝ ██║██║  ██║███████╗${colors.reset}`);
+    console.log(`  ${colors.dim}╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝╚═╝  ╚═╝╚══════╝ - CLI v1.0.0${colors.reset}`);
+    console.log('');
+  },
+
+  info(msg) {
+    console.log(`  ${colors.blue}ℹ${colors.reset}  ${msg}`);
+  },
+
+  success(msg) {
+    console.log(`  ${colors.green}✔${colors.reset}  ${colors.bright}${colors.green}${msg}${colors.reset}`);
+  },
+
+  warn(msg) {
+    console.log(`  ${colors.yellow}⚠${colors.reset}  ${colors.yellow}${msg}${colors.reset}`);
+  },
+
+  error(msg) {
+    console.error(`  ${colors.red}✖${colors.reset}  ${colors.bright}${colors.red}${msg}${colors.reset}`);
+  },
+
+  step(num, title) {
+    console.log(`\n  ${colors.bgBlue}${colors.white}${colors.bright} [${num}] ${colors.reset} ${colors.bright}${title}${colors.reset}`);
+  },
+
+  code(snippet) {
+    console.log(`\n    ${colors.gray}┌──────────────────────────────────────────┐${colors.reset}`);
+    snippet.split('\n').forEach(line => {
+      console.log(`    ${colors.gray}│${colors.reset}  ${colors.cyan}${line}${colors.reset}`);
+    });
+    console.log(`    ${colors.gray}└──────────────────────────────────────────┘${colors.reset}\n`);
+  }
+};