create-snapify-app 0.0.0-stage → 1.1.1

package/LICENSE.md

@@ -0,0 +1,24 @@
+# Licence — create-snapify-app / Snapify
+
+Copyright © 2026 NOVALABS WEB DESIGN — Tunisie  
+Contact : contact@novalabs.tn · +216 24 734 647
+
+Tous droits réservés.
+
+Ce paquet npm (`create-snapify-app`) et le code source Snapify qu’il embarque sont la propriété exclusive de
+NOVALABS WEB DESIGN.
+
+## Autorisation d’installation
+
+NOVALABS autorise l’utilisation de ce paquet **uniquement pour installer et exploiter une instance Snapify** sur
+votre propre hébergement, sous réserve d’une licence Snapify valide lorsque celle-ci est requise.
+
+## Restrictions
+
+Sauf accord écrit de NOVALABS WEB DESIGN, il est interdit de :
+
+- redistribuer, republier ou revendre le code source, modifié ou non ;
+- utiliser le code pour créer un produit concurrent ;
+- retirer les mentions de copyright.
+
+CE LOGICIEL EST FOURNI « EN L’ÉTAT », SANS GARANTIE D’AUCUNE SORTE.

package/README.md

@@ -1,3 +1,56 @@
-# Temporary Holding Version
+# create-snapify-app
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Installe **Snapify** (CMS + e-commerce : backend Express et frontends React) en une commande.
+
+```bash
+npx create-snapify-app@latest mon-site
+```
+
+Le wizard demande :
+
+1. **Domaine** (ex. `boutique.exemple.tn`) → URL publique HTTPS  
+2. **PostgreSQL** (hôte, port, utilisateur, mot de passe, base) — ou une `DATABASE_URL` complète  
+3. **Compte admin** (e-mail + mot de passe)
+
+Puis le CLI copie le code source, écrit `.env`, lance `npm install` et `npm run build`.
+
+```bash
+cd mon-site
+NODE_ENV=production npm start
+```
+
+Administration : `https://votre-domaine/administrator`
+
+## Prérequis
+
+- **Node.js** 22+ (ou ≥ 20.19)
+- **PostgreSQL** 17 (instance existante, ou `docker compose` fourni dans le projet)
+
+## Sans questions (CI / scripts)
+
+```bash
+npx create-snapify-app@latest mon-site --yes \
+  --domain boutique.exemple.tn \
+  --database-url "postgres://user:pass@127.0.0.1:5432/snapify" \
+  --admin-email admin@exemple.tn \
+  --admin-password 'MotDePasseFort1'
+```
+
+## Publication (mainteneurs NOVALABS)
+
+Depuis le dépôt Snapify :
+
+```bash
+npm run app:pack
+npm run app:publish -- --dry-run
+npm run app:publish -- --otp 123456
+```
+
+## Différence avec `create-snapify`
+
+| Paquet | Rôle |
+| --- | --- |
+| `create-snapify` | Projet **module / thème** (kit développeur) |
+| `create-snapify-app` | **CMS Snapify complet** (site + admin) |
+
+© 2026 NOVALABS WEB DESIGN — Tunisie. Licence : voir `LICENSE.md`.

package/bin/create-snapify-app.mjs

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+/*! create-snapify-app — © 2026 NOVALABS WEB DESIGN — licence : LICENSE.md */
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { parseArgs, printHelp } from '../lib/args.mjs';
+import { copyTemplate } from '../lib/copy.mjs';
+import {
+  buildDatabaseUrl,
+  buildEnvFile,
+  domainFromPublicUrl,
+  normalizePublicUrl,
+} from '../lib/env.mjs';
+import { ask, askSecret, askYesNo } from '../lib/prompt.mjs';
+
+const { flags, positionals } = parseArgs(process.argv.slice(2));
+
+if (flags.help) {
+  printHelp();
+  process.exit(0);
+}
+
+const nonInteractive = Boolean(flags.yes);
+const skipInstall = Boolean(flags['skip-install']);
+
+function fail(msg) {
+  console.error(`✖ ${msg}`);
+  process.exit(1);
+}
+
+function ok(msg) {
+  console.log(`✔ ${msg}`);
+}
+
+async function main() {
+  console.log('\n  Snapify — installation complète (backend + frontend)\n');
+
+  const targetName = positionals[0] || (nonInteractive ? 'snapify' : await ask('Dossier du projet', 'snapify'));
+  const dest = path.resolve(process.cwd(), targetName);
+
+  let publicUrl;
+  if (flags.domain) {
+    publicUrl = normalizePublicUrl(String(flags.domain));
+  } else if (nonInteractive) {
+    fail('--domain est requis avec --yes');
+  } else {
+    publicUrl = normalizePublicUrl(await ask('Domaine public (ex. boutique.exemple.tn)', 'localhost:3000'));
+    if (publicUrl.includes('localhost')) {
+      publicUrl = publicUrl.replace(/^https:/, 'http:');
+    }
+  }
+  const domain = domainFromPublicUrl(publicUrl);
+
+  let databaseUrl = flags['database-url'] ? String(flags['database-url']) : '';
+  if (!databaseUrl) {
+    if (nonInteractive && !(flags['db-host'] && flags['db-user'] && flags['db-password'] && flags['db-name'])) {
+      fail('--database-url ou --db-* requis avec --yes');
+    }
+    if (!nonInteractive) {
+      console.log('\n  PostgreSQL');
+      const paste = await askYesNo('Coller une DATABASE_URL complète', false);
+      if (paste) {
+        databaseUrl = await ask('DATABASE_URL');
+      }
+    }
+    if (!databaseUrl) {
+      const host = String(flags['db-host'] || (!nonInteractive ? await ask('Hôte', '127.0.0.1') : ''));
+      const port = String(flags['db-port'] || (!nonInteractive ? await ask('Port', '5432') : '5432'));
+      const user = String(flags['db-user'] || (!nonInteractive ? await ask('Utilisateur', 'snapify') : ''));
+      const password = String(
+        flags['db-password'] ||
+          (!nonInteractive ? (await askSecret('Mot de passe')) || (await ask('Mot de passe (visible)')) : ''),
+      );
+      const database = String(flags['db-name'] || (!nonInteractive ? await ask('Base', 'snapify') : ''));
+      if (!host || !user || !password || !database) fail('Identifiants PostgreSQL incomplets');
+      databaseUrl = buildDatabaseUrl({ host, port, user, password, database });
+    }
+  }
+
+  let adminEmail = flags['admin-email'] ? String(flags['admin-email']) : '';
+  let adminPassword = flags['admin-password'] ? String(flags['admin-password']) : '';
+  if (!adminEmail) {
+    if (nonInteractive) fail('--admin-email requis avec --yes');
+    adminEmail = await ask('E-mail administrateur', `admin@${domain === 'localhost' ? 'localhost' : domain}`);
+  }
+  if (!adminPassword) {
+    if (nonInteractive) fail('--admin-password requis avec --yes');
+    adminPassword = (await askSecret('Mot de passe administrateur')) || (await ask('Mot de passe administrateur'));
+  }
+  if (adminPassword.length < 8) fail('Mot de passe administrateur : 8 caractères minimum');
+
+  const port = String(flags.port || (!nonInteractive ? await ask('Port d’écoute', '3000') : '3000'));
+
+  console.log(`\n→ Copie des sources vers ${dest}`);
+  await copyTemplate(dest);
+  ok('Sources copiées');
+
+  const envBody = buildEnvFile({
+    databaseUrl,
+    domain,
+    publicUrl,
+    adminEmail,
+    adminPassword,
+    port,
+  });
+  await fs.writeFile(path.join(dest, '.env'), envBody, { mode: 0o600 });
+  ok('.env écrit');
+
+  // Alignement du package.json projet (nom local, plus private pour le site client)
+  try {
+    const pkgPath = path.join(dest, 'package.json');
+    const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+    pkg.name = path.basename(dest).toLowerCase().replace(/[^a-z0-9-_]/g, '-') || 'snapify-site';
+    pkg.private = true;
+    delete pkg.publishConfig;
+    await fs.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+  } catch {
+    /* ignore */
+  }
+
+  if (!skipInstall) {
+    console.log('\n→ npm install…');
+    const install = spawnSync('npm', ['install', '--no-audit', '--no-fund', '--legacy-peer-deps'], {
+      cwd: dest,
+      stdio: 'inherit',
+      env: { ...process.env, NODE_ENV: 'development' },
+    });
+    if (install.status !== 0) fail('npm install a échoué');
+    ok('Dépendances installées');
+
+    console.log('\n→ npm run build…');
+    const build = spawnSync('npm', ['run', 'build'], {
+      cwd: dest,
+      stdio: 'inherit',
+      env: { ...process.env, NODE_ENV: 'development' },
+    });
+    if (build.status !== 0) fail('npm run build a échoué');
+    ok('Frontend compilé');
+  }
+
+  const nginx = `
+# Nginx — à adapter puis activer
+server {
+  server_name ${domain};
+  location / {
+    proxy_pass http://127.0.0.1:${port};
+    proxy_set_header Host $host;
+    proxy_set_header X-Forwarded-Host $host;
+    proxy_set_header X-Forwarded-Proto $scheme;
+    proxy_set_header X-Real-IP $remote_addr;
+  }
+}
+`.trim();
+
+  await fs.writeFile(path.join(dest, 'deploy.nginx.example.conf'), `${nginx}\n`);
+
+  console.log(`
+✔ Snapify est prêt dans ${dest}
+
+Prochaines étapes :
+  1. Vérifiez que PostgreSQL accepte la connexion
+  2. cd ${path.relative(process.cwd(), dest) || '.'}
+  3. NODE_ENV=production npm start
+  4. Pointez le DNS de ${domain} vers ce serveur
+  5. Configurez le reverse-proxy (voir deploy.nginx.example.conf)
+  6. Ouvrez ${publicUrl}/administrator
+     → ${adminEmail}
+
+Astuce Docker Postgres locale :
+  SNAPIFY_DB_PASSWORD=... npm run db:up
+`);
+}
+
+main().catch((e) => fail(e instanceof Error ? e.message : String(e)));

package/lib/args.mjs

@@ -0,0 +1,59 @@
+/**
+ * Parse les arguments CLI.
+ * @param {string[]} argv
+ */
+export function parseArgs(argv) {
+  /** @type {Record<string, string | boolean>} */
+  const flags = {};
+  /** @type {string[]} */
+  const positionals = [];
+
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--') {
+      positionals.push(...argv.slice(i + 1));
+      break;
+    }
+    if (a.startsWith('--')) {
+      const eq = a.indexOf('=');
+      if (eq > 0) {
+        flags[a.slice(2, eq)] = a.slice(eq + 1);
+        continue;
+      }
+      const key = a.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith('-')) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+      continue;
+    }
+    if (a.startsWith('-') && a.length === 2) {
+      const key = a.slice(1);
+      const map = { y: 'yes', h: 'help' };
+      flags[map[key] || key] = true;
+      continue;
+    }
+    positionals.push(a);
+  }
+
+  return { flags, positionals };
+}
+
+export function printHelp() {
+  console.log(`Usage: create-snapify-app [dossier] [options]
+
+Options:
+  --domain <host>              Domaine public (ex. boutique.exemple.tn)
+  --database-url <url>         postgres://user:pass@host:port/db
+  --db-host --db-port --db-user --db-password --db-name
+  --admin-email <email>
+  --admin-password <password>
+  --port <n>                   Port d'écoute (défaut 3000)
+  --skip-install               Ne pas lancer npm install / build
+  --yes, -y                    Mode non interactif (valeurs par défaut / flags)
+  --help, -h                   Aide
+`);
+}

package/lib/copy.mjs

@@ -0,0 +1,44 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+export const PACKAGE_ROOT = path.resolve(HERE, '..');
+export const TEMPLATE_DIR = path.join(PACKAGE_ROOT, 'template');
+
+async function exists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Copie récursive du template vers la cible.
+ * @param {string} dest
+ */
+export async function copyTemplate(dest) {
+  if (!(await exists(TEMPLATE_DIR))) {
+    throw new Error(
+      `Template absent (${TEMPLATE_DIR}). Ce paquet npm est incomplet : republiez avec « npm run app:pack ».`,
+    );
+  }
+  if (await exists(dest)) {
+    const entries = await fs.readdir(dest);
+    if (entries.length > 0) {
+      throw new Error(`Le dossier « ${dest} » n'est pas vide. Choisissez un autre chemin ou videz-le.`);
+    }
+  } else {
+    await fs.mkdir(dest, { recursive: true });
+  }
+  await fs.cp(TEMPLATE_DIR, dest, {
+    recursive: true,
+    filter: (src) => {
+      const base = path.basename(src);
+      if (base === 'node_modules' || base === '.git' || base === '.env') return false;
+      return true;
+    },
+  });
+}

package/lib/env.mjs

@@ -0,0 +1,84 @@
+import crypto from 'node:crypto';
+
+/** @param {number} [bytes] */
+export function randomSecret(bytes = 32) {
+  return crypto.randomBytes(bytes).toString('hex');
+}
+
+/**
+ * @param {object} opts
+ * @param {string} opts.databaseUrl
+ * @param {string} opts.domain
+ * @param {string} opts.publicUrl
+ * @param {string} opts.adminEmail
+ * @param {string} opts.adminPassword
+ * @param {number|string} opts.port
+ * @param {string} [opts.cookieDomain]
+ */
+export function buildEnvFile(opts) {
+  const domain = opts.domain.replace(/^https?:\/\//, '').replace(/\/$/, '').toLowerCase();
+  const publicUrl = opts.publicUrl.replace(/\/$/, '');
+  const cookie =
+    opts.cookieDomain ||
+    (domain.includes('.') ? `.${domain.split('.').slice(-2).join('.')}` : undefined);
+
+  const lines = [
+    `# Généré par create-snapify-app — ${new Date().toISOString()}`,
+    `PORT=${opts.port}`,
+    `NODE_ENV=production`,
+    `DATABASE_URL=${opts.databaseUrl}`,
+    '',
+    `PUBLIC_URL=${publicUrl}`,
+    `SNAPIFY_PUBLIC_URL=${publicUrl}`,
+    `SNAPIFY_ADMIN_URL=${publicUrl}/administrator`,
+    cookie ? `PLATFORM_COOKIE_DOMAIN=${cookie}` : '# PLATFORM_COOKIE_DOMAIN=',
+    '',
+    `ADMIN_EMAIL=${opts.adminEmail}`,
+    `ADMIN_PASSWORD=${opts.adminPassword}`,
+    `ADMIN_JWT_SECRET=${randomSecret(32)}`,
+    `SNAPIFY_SECRET_KEY=${randomSecret(32)}`,
+    '',
+    '# Marketplace distante (recommandé en production)',
+    'MARKETPLACE_URL=https://marketplace.snapify.tn/api/marketplace/catalog.json',
+    'SNAPIFY_MODULES_DEV_MODE=false',
+    '',
+    'FLOUCI_MOCK=false',
+    '',
+    '# Superadmin plateforme — changez immédiatement',
+    'SUPERADMIN_USERNAME=admin',
+    `SUPERADMIN_PASSWORD=${randomSecret(12)}`,
+    `SUPERADMIN_SECRET=${randomSecret(24)}`,
+    '',
+    'GEMINI_API_KEY=',
+    'SMTP_HOST=',
+    'SMTP_PORT=587',
+    'SMTP_USER=',
+    'SMTP_PASS=',
+    `SMTP_FROM=contact@${domain}`,
+  ];
+
+  return `${lines.join('\n')}\n`;
+}
+
+/**
+ * Construit une DATABASE_URL à partir des pièces.
+ * @param {{ host: string, port: string|number, user: string, password: string, database: string }} p
+ */
+export function buildDatabaseUrl(p) {
+  const user = encodeURIComponent(p.user);
+  const password = encodeURIComponent(p.password);
+  return `postgres://${user}:${password}@${p.host}:${p.port}/${p.database}`;
+}
+
+/** @param {string} domainOrUrl */
+export function normalizePublicUrl(domainOrUrl) {
+  const raw = domainOrUrl.trim();
+  if (!raw) throw new Error('Domaine requis');
+  if (/^https?:\/\//i.test(raw)) return raw.replace(/\/$/, '');
+  return `https://${raw.replace(/\/$/, '')}`;
+}
+
+/** @param {string} publicUrl */
+export function domainFromPublicUrl(publicUrl) {
+  return new URL(publicUrl).hostname;
+}

package/lib/prompt.mjs

@@ -0,0 +1,63 @@
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+
+/** @param {string} question @param {string} [fallback] */
+export async function ask(question, fallback = '') {
+  const rl = readline.createInterface({ input, output });
+  try {
+    const hint = fallback ? ` (${fallback})` : '';
+    const answer = (await rl.question(`${question}${hint} : `)).trim();
+    return answer || fallback;
+  } finally {
+    rl.close();
+  }
+}
+
+/** @param {string} question */
+export async function askSecret(question) {
+  const rl = readline.createInterface({ input, output });
+  try {
+    output.write(`${question} : `);
+    const wasRaw = input.isRaw;
+    if (input.isTTY) input.setRawMode?.(true);
+    let value = '';
+    await new Promise((resolve) => {
+      const onData = (buf) => {
+        const s = buf.toString('utf8');
+        for (const ch of s) {
+          if (ch === '\n' || ch === '\r' || ch === '\u0004') {
+            input.off('data', onData);
+            if (input.isTTY) input.setRawMode?.(wasRaw ?? false);
+            output.write('\n');
+            resolve();
+            return;
+          }
+          if (ch === '\u0003') {
+            input.off('data', onData);
+            if (input.isTTY) input.setRawMode?.(wasRaw ?? false);
+            output.write('\n');
+            process.exit(130);
+          }
+          if (ch === '\u007f' || ch === '\b') {
+            value = value.slice(0, -1);
+            continue;
+          }
+          value += ch;
+          output.write('*');
+        }
+      };
+      input.on('data', onData);
+    });
+    return value;
+  } finally {
+    rl.close();
+  }
+}
+
+/** @param {string} question @param {boolean} [fallback] */
+export async function askYesNo(question, fallback = true) {
+  const def = fallback ? 'O/n' : 'o/N';
+  const answer = (await ask(`${question} [${def}]`, '')).toLowerCase();
+  if (!answer) return fallback;
+  return answer === 'o' || answer === 'oui' || answer === 'y' || answer === 'yes';
+}

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "create-snapify-app",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.1",
+  "description": "Installe Snapify (CMS complet : backend + frontend) : npx create-snapify-app@latest",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "author": "NOVALABS WEB DESIGN <contact@novalabs.tn> (https://novalabs.tn)",
+  "homepage": "https://snapify.tn",
+  "bugs": {
+    "email": "contact@novalabs.tn"
+  },
+  "keywords": [
+    "snapify",
+    "cms",
+    "create",
+    "installer",
+    "ecommerce",
+    "postgresql",
+    "novalabs"
+  ],
+  "type": "module",
+  "bin": {
+    "create-snapify-app": "bin/create-snapify-app.mjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "template",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/template/.env.example

@@ -0,0 +1,79 @@
+PORT=3000
+
+# PostgreSQL (obligatoire)
+DATABASE_URL=postgres://snapify:changez-moi@127.0.0.1:5432/snapify
+# Conteneur Docker local (npm run db:up)
+SNAPIFY_DB_PASSWORD=changez-moi
+SNAPIFY_DB_PORT=5433
+
+# URL publique du site (utilisée au premier démarrage pour settings.publicUrl)
+PUBLIC_URL=https://exemple.tn
+SNAPIFY_PUBLIC_URL=https://exemple.tn
+
+# Module « Assistant IA » (novalabs.ai-chat) — clé lue uniquement côté serveur
+GEMINI_API_KEY=
+
+# Community + Marketplace + portail développeurs (sous-domaines)
+COMMUNITY_HOST=community.snapify.tn,community.snapify.fr,community.localhost
+MARKETPLACE_HOST=marketplace.snapify.tn,marketplace.snapify.fr,marketplace.localhost
+DEVELOPERS_HOST=developers.snapify.tn,developers.snapify.fr,developers.localhost
+COMMUNITY_URL=https://community.snapify.tn
+MARKETPLACE_PUBLIC_URL=https://marketplace.snapify.tn
+PLATFORM_PUBLIC_URL=https://marketplace.snapify.tn
+# Domaine cookie dérivé du Host (.snapify.tn / .snapify.fr) ; fallback :
+PLATFORM_COOKIE_DOMAIN=.snapify.tn
+PLATFORM_ADMIN_EMAIL=admin@snapify.tn
+PLATFORM_ADMIN_PASSWORD=SnapifyAdmin1
+MARKETPLACE_COMMISSION_BPS=3000
+DEVELOPER_FEE_MILLIMES=100000
+FLOUCI_PUBLIC_KEY=
+FLOUCI_PRIVATE_KEY=
+FLOUCI_WEBHOOK_SECRET=
+# true = paiements simulés — ignoré / interdit si NODE_ENV=production
+FLOUCI_MOCK=true
+
+# Modules — catalogue distant HTTPS (vide = catalogue local marketplace/catalog.json)
+# Pointer vers le catalogue généré par la plateforme :
+# MARKETPLACE_URL=https://marketplace.snapify.tn/api/marketplace/catalog.json
+MARKETPLACE_URL=
+# true = autorise l'installation de modules non signés (développement uniquement)
+SNAPIFY_MODULES_DEV_MODE=false
+
+# Backoffice — changez impérativement en production
+ADMIN_EMAIL=admin@snapify.fr
+ADMIN_PASSWORD=changez-moi
+ADMIN_JWT_SECRET=long-random-secret
+# Clé de chiffrement des secrets en base (mot de passe SMTP, 2FA). Vide = dérivée d'ADMIN_JWT_SECRET.
+# Ne plus la changer une fois définie : les secrets déjà chiffrés deviendraient illisibles.
+SNAPIFY_SECRET_KEY=
+# Adresse de l'administration utilisée dans les e-mails (invitation, mot de passe oublié). Vide = URL publique du site.
+SNAPIFY_ADMIN_URL=
+# Secours : true = ignore la liste d'IP autorisées de l'administration (à remettre à false après usage)
+SNAPIFY_ADMIN_IP_BYPASS=false
+
+# Google OAuth (Search Console) — facultatif : l'assistant SEO › Google Search Console
+# permet de saisir ces identifiants dans l'admin (prioritaires, secret chiffré).
+# GOOGLE_REDIRECT_URI n'est utilisé qu'avec les identifiants définis ici.
+GOOGLE_CLIENT_ID=
+GOOGLE_CLIENT_SECRET=
+GOOGLE_REDIRECT_URI=https://snapify.fr/api/admin/google/callback
+
+# E-mails (formulaires, newsletter double opt-in, invitations). Utilisé seulement si le SMTP
+# n'est pas configuré dans Paramètres › E-mails, qui a priorité.
+SMTP_HOST=
+SMTP_PORT=587
+SMTP_USER=
+SMTP_PASS=
+SMTP_FROM=contact@snapify.fr
+
+# Démo publique snapify.tn/demo (credentials affichés + reset CMS 24h)
+DEMO_ADMIN_EMAIL=admin@snapify.fr
+DEMO_ADMIN_PASSWORD=SnapifyDemo1
+DEMO_CMS_RESET=true
+DEMO_CMS_RESET_HOURS=24
+LICENSE_PRICE_MILLIMES=699000
+
+# Superadmin (https://snapify.tn/hamdisup90) — SUPERADMIN_PASSWORD obligatoire (pas de défaut)
+SUPERADMIN_USERNAME=hamdisup90
+SUPERADMIN_PASSWORD=changez-moi
+SUPERADMIN_SECRET=

package/template/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: Lint & build
+    runs-on: [self-hosted, linux, x64]
+    timeout-minutes: 25
+    steps:
+      - uses: actions/checkout@v4
+      - run: npm ci --no-audit --no-fund --legacy-peer-deps
+      - run: npm run lint
+      - run: npm run build

package/template/.github/workflows/deploy.yml

@@ -0,0 +1,26 @@
+name: Deploy
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+    inputs:
+      ref:
+        description: 'Git ref (origin/main ou tags/v1.1.0)'
+        required: false
+        default: origin/main
+
+concurrency:
+  group: deploy-production
+  cancel-in-progress: false
+
+jobs:
+  deploy:
+    name: Production (hamdi)
+    runs-on: [self-hosted, linux, x64]
+    timeout-minutes: 30
+    steps:
+      - name: Deploy Snapify
+        env:
+          REF: ${{ github.event.inputs.ref || 'origin/main' }}
+        run: sudo -n bash /home/snapify/scripts/deploy.sh "$REF"

package/template/.github/workflows/ping.yml

@@ -0,0 +1,8 @@
+name: Ping
+on:
+  workflow_dispatch:
+jobs:
+  ping:
+    runs-on: self-hosted
+    steps:
+      - run: echo hello-from-hamdi && hostname