@lystech/core 1.0.1

package/README.md

@@ -0,0 +1,2 @@
+
+<!-- Test auto-publish workflow - 2026-04-03 14:19:11 -->

package/bin/README.md

@@ -0,0 +1,126 @@
+# 📦 Scripts LystechCoreNpmPackage
+
+## Commandes Disponibles
+
+### 🔗 `npx lystechcorenpmpackage attach`
+
+**Attache votre projet au système de mise à jour automatique.**
+
+```bash
+npx lystechcorenpmpackage attach
+```
+
+**Ce que ça fait:**
+
+- Détecte automatiquement votre repo GitHub
+- Génère la configuration pour `consumers.json`
+- Guide pour compléter le setup (PR, secrets, etc.)
+
+**Fichier**: `bin/attach.cjs`
+
+---
+
+### ⚙️ `npx lystechcorenpmpackage lystech-auto-update-init` (Legacy)
+
+**Crée un workflow optionnel de fallback dans votre projet.**
+
+```bash
+npx lystechcorenpmpackage lystech-auto-update-init [--force]
+```
+
+**Options:**
+
+- `--force`: Écrase le workflow existant
+- `--dry-run`: Affiche le YAML sans créer de fichier
+- `--package=<name>`: Nom du package à surveiller
+- `--deploy-script=<script>`: Script de déploiement custom
+
+**Note**: Ce workflow n'est plus nécessaire avec le nouveau système centralisé, mais peut servir de fallback manuel.
+
+**Fichier**: `bin/setup-github-action.cjs`
+
+---
+
+### 🔍 `npx lystechcorenpmpackage check-pwa`
+
+**Vérifie la configuration PWA de votre projet.**
+
+```bash
+npx lystechcorenpmpackage check-pwa
+```
+
+**Fichier**: `bin/check-pwa.cjs`
+
+---
+
+## 🚀 Workflow Recommandé pour Nouveaux Projets
+
+```bash
+# 1. Installer le package
+npm install lystechcorenpmpackage
+
+# 2. Attacher au système de mise à jour
+npx lystechcorenpmpackage attach
+
+# 3. Suivre les instructions affichées
+
+# ✅ Terminé!
+```
+
+---
+
+## 🔧 Pour les Développeurs du Package
+
+### Structure
+
+```
+bin/
+├── attach.cjs                 # Commande principale d'attachement
+├── setup-github-action.cjs    # (Legacy) Génération de workflow local
+├── check-pwa.cjs              # Vérification PWA
+├── notify-consumers.cjs       # (Legacy) Notification manuelle
+└── README.md                  # Ce fichier
+```
+
+### Ajouter une Nouvelle Commande
+
+1. Créer le fichier dans `bin/`
+2. Ajouter le shebang: `#!/usr/bin/env node`
+3. Rendre exécutable: `chmod +x bin/nouvelle-commande.cjs`
+4. Ajouter dans `package.json` → `bin`:
+   ```json
+   {
+     "bin": {
+       "nouvelle-commande": "./bin/nouvelle-commande.cjs"
+     }
+   }
+   ```
+
+### Tester Localement
+
+```bash
+# Depuis le package
+node bin/attach.cjs
+
+# Ou depuis n'importe où
+npm link
+npx lystechcorenpmpackage attach
+npm unlink
+```
+
+---
+
+## 📚 Documentation
+
+- [Guide d'attachement](../ATTACH-GUIDE.md) - Guide utilisateur pour `attach`
+- [Guide Auto-Update complet](../AUTO-UPDATE-GUIDE.md) - Documentation complète du système
+- [consumers.json](../consumers.json) - Configuration des projets
+
+---
+
+## 🆘 Support
+
+Pour toute question ou problème:
+
+- 📖 Lire la documentation ci-dessus
+- 🐛 [Créer une issue](https://github.com/eracine4/lystechcorenpmpackage/issues)

package/bin/attach.cjs

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+
+/**
+ * Script pour attacher un projet au système de mise à jour automatique
+ *
+ * Usage: npx lystechcorenpmpackage attach
+ *
+ * Ce script:
+ * 1. Détecte le repo GitHub actuel
+ * 2. Génère la configuration pour consumers.json
+ * 3. Guide l'utilisateur pour compléter le setup
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+// Couleurs console
+const colors = {
+  reset: "\x1b[0m",
+  bright: "\x1b[1m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  cyan: "\x1b[36m",
+  red: "\x1b[31m",
+};
+
+function log(message, color = colors.reset) {
+  console.log(`${color}${message}${colors.reset}`);
+}
+
+function header(message) {
+  console.log("");
+  log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`, colors.cyan);
+  log(`  ${message}`, colors.bright + colors.cyan);
+  log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`, colors.cyan);
+  console.log("");
+}
+
+function success(message) {
+  log(`✅ ${message}`, colors.green);
+}
+
+function warning(message) {
+  log(`⚠️  ${message}`, colors.yellow);
+}
+
+function error(message) {
+  log(`❌ ${message}`, colors.red);
+}
+
+function info(message) {
+  log(`ℹ️  ${message}`, colors.blue);
+}
+
+/**
+ * Détecte les informations Git du repo actuel
+ */
+function detectGitInfo() {
+  try {
+    // Vérifier si on est dans un repo git
+    execSync("git rev-parse --git-dir", { stdio: "ignore" });
+
+    // Récupérer l'URL remote
+    const remoteUrl = execSync("git config --get remote.origin.url", {
+      encoding: "utf8",
+    }).trim();
+
+    // Parser l'URL GitHub
+    const match = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/\.]+)/);
+    if (!match) {
+      return null;
+    }
+
+    const [, owner, repo] = match;
+
+    // Récupérer la branche par défaut
+    let defaultBranch = "master";
+    try {
+      defaultBranch = execSync(
+        "git symbolic-ref refs/remotes/origin/HEAD | sed 's@^refs/remotes/origin/@@'",
+        { encoding: "utf8", shell: "bash" },
+      ).trim();
+    } catch {
+      // Essayer une autre méthode
+      try {
+        defaultBranch =
+          execSync("git branch -r", { encoding: "utf8" })
+            .split("\n")
+            .find((b) => b.includes("HEAD"))
+            ?.split("->")[1]
+            ?.trim()
+            ?.replace("origin/", "") || "master";
+      } catch {
+        // Garder master par défaut
+      }
+    }
+
+    return { owner, repo, branch: defaultBranch };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Lit le package.json du projet
+ */
+function readPackageJson() {
+  const packageJsonPath = path.join(process.cwd(), "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return null;
+  }
+  return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+}
+
+/**
+ * Génère la configuration pour consumers.json
+ */
+function generateConsumerConfig(gitInfo, packageJson) {
+  const scripts = packageJson?.scripts || {};
+
+  return {
+    owner: gitInfo.owner,
+    repo: gitInfo.repo,
+    branch: gitInfo.branch,
+    enabled: true,
+    buildScript: scripts.build ? "build" : "",
+    deployScript: scripts.deploy ? "deploy" : "",
+    deployTarget: scripts.deploy?.includes("firebase")
+      ? "firebase"
+      : scripts.deploy?.includes("vercel")
+        ? "vercel"
+        : "custom",
+    notes: packageJson?.description || `Projet ${gitInfo.repo}`,
+  };
+}
+
+/**
+ * Affiche les instructions pour compléter le setup
+ */
+function printInstructions(config) {
+  header("📋 Configuration générée");
+
+  log(
+    "Ajoutez cette entrée au fichier consumers.json du package:",
+    colors.bright,
+  );
+  console.log("");
+  console.log(JSON.stringify(config, null, 2));
+  console.log("");
+
+  header("🚀 Prochaines étapes");
+
+  log("Pour activer la mise à jour automatique:", colors.bright);
+  console.log("");
+
+  log(
+    "1️⃣  Créer une Pull Request sur le repo lystechcorenpmpackage:",
+    colors.cyan,
+  );
+  console.log("   - Ouvrir: https://github.com/eracine4/lystechcorenpmpackage");
+  console.log("   - Éditer: consumers.json");
+  console.log("   - Ajouter la configuration ci-dessus");
+  console.log("");
+
+  log("2️⃣  Configurer le token GitHub (dans le repo du package):", colors.cyan);
+  console.log("   Si ce n'est pas déjà fait:");
+  console.log("   a) Créer un Personal Access Token:");
+  console.log(
+    "      https://github.com/settings/tokens/new?scopes=repo&description=Lystech%20Auto%20Update",
+  );
+  console.log("   b) Ajouter le secret CONSUMER_UPDATE_TOKEN:");
+  console.log(
+    "      https://github.com/eracine4/lystechcorenpmpackage/settings/secrets/actions",
+  );
+  console.log("");
+
+  if (config.deployScript) {
+    log(
+      `3️⃣  Configurer les secrets de déploiement (${config.deployTarget}):`,
+      colors.cyan,
+    );
+    console.log(
+      `   Dans votre repo: https://github.com/${config.owner}/${config.repo}/settings/secrets/actions`,
+    );
+
+    if (config.deployTarget === "firebase") {
+      console.log("   - FIREBASE_TOKEN (requis pour npm run deploy)");
+    } else if (config.deployTarget === "vercel") {
+      console.log("   - VERCEL_TOKEN");
+    }
+    console.log("");
+  }
+
+  log(
+    "✅ Une fois la PR mergée, vos updates seront automatiques!",
+    colors.green,
+  );
+  console.log("");
+  info(
+    "Le package mettra à jour ce projet automatiquement à chaque publication.",
+  );
+}
+
+/**
+ * Crée un fichier de référence local
+ */
+function createLocalReference(config) {
+  const refPath = path.join(process.cwd(), ".lystech-auto-update.json");
+  fs.writeFileSync(refPath, JSON.stringify(config, null, 2));
+  success(`Configuration sauvegardée dans: .lystech-auto-update.json`);
+  warning(
+    "Ajoutez ce fichier au .gitignore si vous ne voulez pas le committer",
+  );
+}
+
+/**
+ * Main
+ */
+function main() {
+  header("🔗 Lystech Auto-Update - Attachement");
+
+  // Détecter le repo
+  const gitInfo = detectGitInfo();
+  if (!gitInfo) {
+    error("Impossible de détecter les informations Git");
+    console.log("Assurez-vous d'être dans un repo GitHub cloné");
+    process.exit(1);
+  }
+
+  success(
+    `Repo détecté: ${gitInfo.owner}/${gitInfo.repo} (branche: ${gitInfo.branch})`,
+  );
+
+  // Lire package.json
+  const packageJson = readPackageJson();
+  if (!packageJson) {
+    error("package.json introuvable");
+    process.exit(1);
+  }
+
+  success(`Projet: ${packageJson.name || gitInfo.repo}`);
+
+  // Vérifier si le package est installé
+  const hasPackage =
+    packageJson.dependencies?.lystechcorenpmpackage ||
+    packageJson.devDependencies?.lystechcorenpmpackage;
+
+  if (!hasPackage) {
+    warning("lystechcorenpmpackage n'est pas dans les dépendances");
+    console.log("Installez-le d'abord: npm install lystechcorenpmpackage");
+    console.log("");
+  }
+
+  // Générer la config
+  const config = generateConsumerConfig(gitInfo, packageJson);
+
+  // Sauvegarder localement
+  createLocalReference(config);
+
+  // Afficher les instructions
+  printInstructions(config);
+}
+
+// Point d'entrée
+if (require.main === module) {
+  try {
+    main();
+  } catch (err) {
+    error(`Erreur: ${err.message}`);
+    console.error(err);
+    process.exit(1);
+  }
+}
+
+module.exports = { detectGitInfo, generateConsumerConfig };

package/bin/check-pwa.cjs

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+
+// Script universel de vérification PWA pour un projet Node.js (CommonJS)
+const fs = require("fs");
+const path = require("path");
+
+function findFileUpwards(filename, startDir = process.cwd()) {
+  let dir = startDir;
+  while (dir !== path.parse(dir).root) {
+    const candidate = path.join(dir, filename);
+    if (fs.existsSync(candidate)) return candidate;
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+function checkManifest(autoCreate = false) {
+  const manifestPaths = [
+    findFileUpwards("public/manifest.json"),
+    findFileUpwards("manifest.json"),
+  ].filter(Boolean);
+  const defaultManifest = {
+    name: "Lystech Core",
+    short_name: "Lystech",
+    start_url: ".",
+    display: "standalone",
+    background_color: "#ffffff",
+    theme_color: "#000000",
+    icons: [
+      {
+        src: "/logo.png",
+        sizes: "192x192",
+        type: "image/png",
+      },
+      {
+        src: "/logo.png",
+        sizes: "512x512",
+        type: "image/png",
+      },
+    ],
+  };
+  let manifestPath = manifestPaths[0];
+  if (!manifestPath && autoCreate) {
+    const publicDir = findFileUpwards("public") || process.cwd();
+    manifestPath = fs.existsSync(path.join(publicDir, "public"))
+      ? path.join(publicDir, "public", "manifest.json")
+      : path.join(publicDir, "manifest.json");
+    fs.writeFileSync(manifestPath, JSON.stringify(defaultManifest, null, 2));
+    console.log("🟢 manifest.json créé :", manifestPath);
+    return manifestPath;
+  }
+  if (manifestPath) {
+    let content;
+    try {
+      content = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    } catch (e) {
+      if (autoCreate) {
+        fs.writeFileSync(
+          manifestPath,
+          JSON.stringify(defaultManifest, null, 2)
+        );
+        console.log("🟢 manifest.json réparé :", manifestPath);
+        return manifestPath;
+      } else {
+        console.error("❌ manifest.json illisible :", manifestPath);
+        return false;
+      }
+    }
+    let changed = false;
+    for (const key of Object.keys(defaultManifest)) {
+      if (!(key in content)) {
+        content[key] = defaultManifest[key];
+        changed = true;
+        console.log(`🟢 Champ ajouté à manifest.json : ${key}`);
+      }
+    }
+    if (changed && autoCreate) {
+      fs.writeFileSync(manifestPath, JSON.stringify(content, null, 2));
+      console.log("🟢 manifest.json mis à jour :", manifestPath);
+    } else {
+      console.log("✅ manifest.json trouvé :", manifestPath);
+    }
+    return manifestPath;
+  }
+  console.error(
+    "❌ Aucun manifest.json trouvé (ni dans public/, ni à la racine)"
+  );
+  return false;
+}
+
+function checkServiceWorker(autoCreate = false) {
+  const swPaths = [
+    findFileUpwards("public/service-worker.js"),
+    findFileUpwards("service-worker.js"),
+  ].filter(Boolean);
+  const requiredFunctions = {
+    install: `self.addEventListener("install", (event) => {
+  self.skipWaiting();
+});`,
+    activate: `self.addEventListener("activate", (event) => {
+  event.waitUntil(self.clients.claim());
+});`,
+    push: `self.addEventListener("push", (event) => {
+  const data = event.data ? event.data.json() : {};
+  const title = data.title || "Nouvelle notification";
+  const options = {
+    body: data.body || "Vous avez une nouvelle notification.",
+    icon: data.icon || "https://placehold.co/192x192/000000/FFFFFF?text=PUSH",
+    badge: data.badge || "https://placehold.co/72x72/000000/FFFFFF?text=BADGE",
+    image: data.image,
+    data: {
+      url: data.data?.url || "/",
+    },
+    actions: data.actions || [],
+    vibrate: [200, 100, 200],
+  };
+  event.waitUntil(self.registration.showNotification(title, options));
+});`,
+    notificationclick: `self.addEventListener("notificationclick", (event) => {
+  event.notification.close();
+  const clickedNotification = event.notification;
+  const urlToOpen = clickedNotification.data.url;
+  event.waitUntil(
+    self.clients.matchAll({ type: "window" }).then((clientList) => {
+      for (const client of clientList) {
+        if (client.url === urlToOpen && "focus" in client) {
+          return client.focus();
+        }
+      }
+      if (self.clients.openWindow) {
+        return self.clients.openWindow(urlToOpen);
+      }
+    })
+  );
+});`,
+  };
+  let swPath = swPaths[0];
+  if (!swPath && autoCreate) {
+    const publicDir = findFileUpwards("public") || process.cwd();
+    swPath = fs.existsSync(path.join(publicDir, "public"))
+      ? path.join(publicDir, "public", "service-worker.js")
+      : path.join(publicDir, "service-worker.js");
+    const swContent = Object.values(requiredFunctions).join("\n\n");
+    fs.writeFileSync(swPath, swContent);
+    console.log("🟢 service-worker.js créé :", swPath);
+    return swPath;
+  }
+  if (swPath) {
+    let content = fs.readFileSync(swPath, "utf8");
+    let changed = false;
+    function escapeRegExp(str) {
+      return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    for (const fn of Object.values(requiredFunctions)) {
+      const signature = fn.split("\n")[0].trim();
+      // On veut matcher jusqu'à la fermeture de l'accolade et du parenthèse, peu importe les espaces
+      const regex = new RegExp(
+        escapeRegExp(signature) + "[\\s\\S]*?\\}s*\\);",
+        "gm"
+      );
+      if (regex.test(content)) {
+        // Remplacer la fonction existante par la version canonique
+        content = content.replace(regex, fn);
+        changed = true;
+        console.log(`🟢 Fonction remplacée : ${signature}`);
+      } else {
+        // Ajouter la fonction manquante
+        content += "\n\n" + fn;
+        changed = true;
+        console.log(`🟢 Fonction ajoutée : ${signature}`);
+      }
+    }
+    if (changed && autoCreate) {
+      fs.writeFileSync(swPath, content.trim() + "\n");
+      console.log("🟢 service-worker.js mis à jour :", swPath);
+    } else {
+      console.log("✅ service-worker.js trouvé :", swPath);
+    }
+    return swPath;
+  }
+  console.error(
+    "❌ Aucun service-worker.js trouvé (ni dans public/, ni à la racine)"
+  );
+  return false;
+}
+
+function checkIndexHtmlForManifestAndAppleTags(autoCreate = false) {
+  const indexPaths = [
+    findFileUpwards("public/index.html"),
+    findFileUpwards("index.html"),
+  ].filter(Boolean);
+  if (indexPaths.length === 0) {
+    console.error(
+      "❌ Aucun index.html trouvé (ni dans public/, ni à la racine)"
+    );
+    return false;
+  }
+  const indexPath = indexPaths[0];
+  let lines = fs.readFileSync(indexPath, "utf8").split(/\r?\n/);
+  let ok = true;
+  const requiredLines = [
+    '<link rel="manifest" href="/manifest.json" />',
+    '<meta name="apple-mobile-web-app-capable" content="yes" />',
+    '<meta name="apple-mobile-web-app-status-bar-style" content="default" />',
+    '<meta name="apple-mobile-web-app-title" content="Lystech Core" />',
+    '<link rel="apple-touch-icon" href="/logo.png" />',
+  ];
+  let changed = false;
+  for (const tag of requiredLines) {
+    if (lines.some((l) => l.includes(tag.replace(/\s*\/?>$/, "")))) {
+      console.log(`✅ ${tag} trouvé dans`, indexPath);
+    } else {
+      ok = false;
+      if (autoCreate) {
+        // Ajoute la ligne avant </head>
+        const headIdx = lines.findIndex((l) => l.match(/<\/head>/i));
+        if (headIdx !== -1) {
+          lines.splice(headIdx, 0, tag);
+          changed = true;
+          console.log(`🟢 ${tag} ajouté dans`, indexPath);
+        }
+      } else {
+        console.error(`❌ ${tag} manquant dans`, indexPath);
+      }
+    }
+  }
+  if (changed && autoCreate) {
+    fs.writeFileSync(indexPath, lines.join("\n"));
+    ok = true;
+  }
+  return ok;
+}
+
+function main() {
+  console.log("--- Vérification Progressive Web App ---");
+  const autoCreate =
+    process.argv.includes("--fix") || process.argv.includes("--create");
+  const manifest = checkManifest(autoCreate);
+  const serviceWorker = checkServiceWorker(autoCreate);
+  const indexHasManifestAndApple =
+    checkIndexHtmlForManifestAndAppleTags(autoCreate);
+
+  // Ajout automatique du script check-pwa dans package.json si absent
+  const pkgPath = findFileUpwards("package.json");
+  if (pkgPath) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+      if (!pkg.scripts) pkg.scripts = {};
+      if (!pkg.scripts["check-pwa"]) {
+        pkg.scripts["check-pwa"] = "npx lystechcorenpmpackage check-pwa --fix";
+        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+        console.log("🟢 Script 'check-pwa' ajouté dans package.json");
+      } else {
+        console.log("✅ Script 'check-pwa' déjà présent dans package.json");
+      }
+    } catch (e) {
+      console.error(
+        "❌ Erreur lors de la mise à jour du package.json :",
+        e.message
+      );
+    }
+  }
+  if (manifest && serviceWorker && indexHasManifestAndApple) {
+    console.log("🎉 Votre projet est prêt pour la Progressive Web App!");
+    process.exit(0);
+  } else {
+    if (!manifest && autoCreate)
+      console.error("Impossible de créer/mettre à jour manifest.json");
+    if (!serviceWorker && autoCreate)
+      console.error("Impossible de créer/mettre à jour service-worker.js");
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}