create-snapify-app 0.0.0-stage → 1.1.1

package/template/server/modules/themeHtml.ts

@@ -0,0 +1,32 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+import { publicTheme } from './manager';
+
+const attr = (v: string) => v.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;');
+
+/**
+ * Feuille de style et script du thème actif annoncés dès le HTML : pas de flash sans style.
+ * Le descripteur est aussi inclus, car le HTML n'est jamais mis en cache alors que
+ * /api/public/site-config peut l'être quelques secondes après un changement de thème.
+ */
+export async function injectTheme(html: string): Promise<string> {
+  try {
+    const theme = await publicTheme();
+    if (!theme) return html;
+    const json = JSON.stringify(theme).replace(/</g, '\\u003c');
+    const tags = [
+      theme.style ? `<link rel="stylesheet" href="${attr(theme.style)}" data-snapify-theme="${attr(theme.id)}" />` : '',
+      `<link rel="modulepreload" href="${attr(theme.script)}" />`,
+      `<script type="application/json" id="snapify-theme">${json}</script>`,
+    ]
+      .filter(Boolean)
+      .join('\n    ');
+    return html.replace('</head>', `    ${tags}\n  </head>`);
+  } catch {
+    return html;
+  }
+}

package/template/server/modules/trust.ts

@@ -0,0 +1,16 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+/**
+ * Clés publiques NOVALABS acceptées pour la signature des modules et des licences
+ * (identifiant de clé → clé SPKI Ed25519 en base64). Ajouter une clé lors d'une rotation,
+ * retirer l'ancienne une fois tous les paquets re-signés.
+ */
+export const TRUSTED_KEYS: Readonly<Record<string, string>> = Object.freeze({
+  'novalabs-2026': 'MCowBQYDK2VwAyEAJIWXFiaxzBQe042IMZUo/IGiKLGtTf7XBywgS6cpHWs=',
+  /** Clé locale de développement (signature de nouveaux paquets sur cet environnement). */
+  'novalabs-local-2026': 'MCowBQYDK2VwAyEAAp4iufU2icDH3Lh7+dm5aQIxm+/jH26ztpg27EZPOLo=',
+});

package/template/server/modules/types.ts

@@ -0,0 +1,147 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+/** Données échangées entre le gestionnaire de modules et l'administration. */
+import type { AdminPageDefinition, ModuleManifest, ModuleSlot, ModuleStatusReport, PackageKind, SettingField, WidgetDefinition } from '../../sdk/index';
+
+/** Module actif tel que transmis au site public (réglages publics uniquement). */
+export interface PublicModuleDescriptor {
+  id: string;
+  version: string;
+  slots: ModuleSlot[];
+  /** Adresses affichées par le composant `page` du module. */
+  routes: string[];
+  /** Identifiants des widgets du bloc « Module ». */
+  widgets: string[];
+  script: string;
+  style?: string;
+  settings: Record<string, unknown>;
+}
+
+/** Thème appliqué au site (ou prévisualisé dans l'administration). */
+export interface PublicThemeDescriptor {
+  id: string;
+  version: string;
+  script: string;
+  style?: string;
+  settings: Record<string, unknown>;
+}
+
+export type ModuleStatusCode =
+  | 'active'
+  | 'disabled'
+  | 'unsigned'
+  | 'incompatible'
+  | 'tampered'
+  | 'license_missing'
+  | 'license_invalid'
+  | 'license_expired'
+  | 'license_domain'
+  | 'dependency'
+  | 'error';
+
+export type LicenseState = 'valid' | 'missing' | 'invalid' | 'expired' | 'domain' | 'dev';
+
+export interface ModuleLicenseInfo {
+  state: LicenseState;
+  message: string;
+  licenseId?: string;
+  licensee?: string;
+  plan?: string;
+  domains?: string[];
+  expiresAt?: string | null;
+}
+
+export interface ModuleSignatureInfo {
+  valid: boolean;
+  kid?: string;
+  /** Module non signé accepté parce que le mode développeur est actif. */
+  devUnsigned: boolean;
+}
+
+export type ModuleSummary = Pick<
+  ModuleManifest,
+  'id' | 'name' | 'version' | 'description' | 'author' | 'pricing' | 'category' | 'icon' | 'permissions' | 'slots'
+>;
+
+export interface InstalledModuleInfo extends ModuleSummary {
+  kind: PackageKind;
+  enabled: boolean;
+  source: 'marketplace' | 'upload';
+  installedAt: string;
+  updatedAt: string;
+  status: { code: ModuleStatusCode; message: string };
+  signature: ModuleSignatureInfo;
+  license: ModuleLicenseInfo;
+  hasSettings: boolean;
+  hasServer: boolean;
+  routes: string[];
+  widgets: WidgetDefinition[];
+  adminPages: AdminPageDefinition[];
+  requires: Record<string, string>;
+  /** Bundle des pages d'administration, si le module est actif. */
+  admin: { script: string; style?: string } | null;
+}
+
+export interface InstalledModuleDetail extends InstalledModuleInfo {
+  settingsSchema: SettingField[];
+  settings: Record<string, unknown>;
+  report: ModuleStatusReport | null;
+}
+
+export interface InstalledThemeInfo extends InstalledModuleInfo {
+  active: boolean;
+  screenshot?: string;
+}
+
+export interface InstalledThemeDetail extends InstalledThemeInfo {
+  settingsSchema: SettingField[];
+  settings: Record<string, unknown>;
+  /** Fichiers du thème pour l'aperçu, si ses vérifications sont satisfaites. */
+  descriptor: PublicThemeDescriptor | null;
+}
+
+export interface CatalogEntry extends ModuleSummary {
+  kind?: PackageKind;
+  /** Chemin relatif au catalogue ; résolu en URL dans la liste renvoyée à l'administration. */
+  screenshot?: string;
+  /** Captures supplémentaires (chemins relatifs), résolues en URL côté listing. */
+  gallery?: string[];
+  /** Prix en millimes pour les modules `paid` (ex. 49000 = 49 DT). */
+  priceMillimes?: number;
+  engines: { snapify: string };
+  package: string;
+  sha256: string;
+  size: number;
+  signed: boolean;
+}
+
+export interface MarketplaceListing {
+  source: 'local' | 'remote';
+  url?: string;
+  error?: string;
+  devMode: boolean;
+  modules: (CatalogEntry & {
+    installedVersion: string | null;
+    updateAvailable: boolean;
+    compatible: boolean;
+    priceLabel?: string;
+    purchased?: boolean;
+  })[];
+}
+
+/** Paquet vérifié en attente de confirmation par l'administrateur. */
+export interface StagedPackageInfo {
+  token: string;
+  manifest: ModuleSummary & { kind: PackageKind; engines: { snapify: string }; hasServer: boolean; settingsCount: number; screenshot?: string };
+  signature: ModuleSignatureInfo;
+  license: ModuleLicenseInfo;
+  compatible: boolean;
+  installedVersion: string | null;
+  /** `install`, `update`, `reinstall` ou `downgrade`. */
+  action: 'install' | 'update' | 'reinstall' | 'downgrade';
+  blockers: string[];
+}

package/template/server/platform/auth.ts

@@ -0,0 +1,223 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+import crypto from 'crypto';
+import type { Request, Response, NextFunction } from 'express';
+import { and, eq, gt, isNull } from 'drizzle-orm';
+import { db } from '../db/client';
+import { platformSessions, platformUsers } from '../db/schema';
+import { HttpError } from '../http';
+import { clientIp } from '../security/ip';
+import { randomToken, sha256 } from '../security/secrets';
+import { hashPassword, validatePlatformPassword, verifyPassword } from './passwords';
+import { platformCookieDomainForHost } from './region';
+
+export type PlatformUser = typeof platformUsers.$inferSelect;
+export type PublicPlatformUser = {
+  id: string;
+  email: string;
+  displayName: string;
+  avatarUrl: string | null;
+  bio: string;
+  role: PlatformUser['role'];
+  createdAt: Date;
+};
+
+const COOKIE = 'sf_platform';
+const SESSION_DAYS = 30;
+const IDLE_MS = 14 * 24 * 3600_000;
+
+declare global {
+  namespace Express {
+    interface Request {
+      platformUser?: PlatformUser;
+      platformSessionId?: string;
+    }
+  }
+}
+
+export function toPublicUser(u: PlatformUser): PublicPlatformUser {
+  return {
+    id: u.id,
+    email: u.email,
+    displayName: u.displayName,
+    avatarUrl: u.avatarUrl,
+    bio: u.bio,
+    role: u.role,
+    createdAt: u.createdAt,
+  };
+}
+
+function cookieDomain(req: Request): string | undefined {
+  const xf = String(req.headers['x-forwarded-host'] || '')
+    .split(',')[0]
+    .trim();
+  const host = (xf || String(req.headers.host || '')).split(':')[0].toLowerCase();
+  return platformCookieDomainForHost(host) || process.env.PLATFORM_COOKIE_DOMAIN?.trim() || undefined;
+}
+
+function setSessionCookie(req: Request, res: Response, sessionId: string, expiresAt: Date) {
+  res.cookie(COOKIE, sessionId, {
+    httpOnly: true,
+    secure: process.env.NODE_ENV === 'production',
+    sameSite: 'lax',
+    domain: cookieDomain(req),
+    path: '/',
+    expires: expiresAt,
+  });
+}
+
+function clearSessionCookie(req: Request, res: Response) {
+  res.clearCookie(COOKIE, { path: '/', domain: cookieDomain(req) });
+}
+
+function readCookie(req: Request): string | null {
+  const header = req.headers.cookie || '';
+  const match = header.match(/(?:^|;\s*)sf_platform=([^;]+)/);
+  return match ? decodeURIComponent(match[1]) : null;
+}
+
+export async function createPlatformUser(input: {
+  email: string;
+  password: string;
+  displayName: string;
+}): Promise<PlatformUser> {
+  const email = input.email.trim().toLowerCase();
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) throw new HttpError(422, 'Adresse e-mail invalide.');
+  const err = validatePlatformPassword(input.password);
+  if (err) throw new HttpError(422, err);
+  const displayName = input.displayName.trim().slice(0, 80);
+  if (displayName.length < 2) throw new HttpError(422, 'Le nom affiché est trop court.');
+
+  const existing = await db.select({ id: platformUsers.id }).from(platformUsers).where(eq(platformUsers.email, email)).limit(1);
+  if (existing.length) throw new HttpError(409, 'Un compte existe déjà avec cet e-mail.');
+
+  const { hash, salt } = hashPassword(input.password);
+  const id = crypto.randomUUID();
+  const [user] = await db
+    .insert(platformUsers)
+    .values({
+      id,
+      email,
+      displayName,
+      passwordHash: hash,
+      salt,
+      role: 'member',
+    })
+    .returning();
+  return user;
+}
+
+export async function loginPlatformUser(
+  req: Request,
+  res: Response,
+  email: string,
+  password: string
+): Promise<PlatformUser> {
+  const normalized = email.trim().toLowerCase();
+  const [user] = await db.select().from(platformUsers).where(eq(platformUsers.email, normalized)).limit(1);
+  if (!user || !verifyPassword(password, user.passwordHash, user.salt)) {
+    throw new HttpError(401, 'E-mail ou mot de passe incorrect.');
+  }
+  const sessionId = randomToken(32);
+  const expiresAt = new Date(Date.now() + SESSION_DAYS * 86400_000);
+  await db.insert(platformSessions).values({
+    id: sessionId,
+    userId: user.id,
+    expiresAt,
+    ip: clientIp(req),
+    userAgent: String(req.headers['user-agent'] || '').slice(0, 300),
+  });
+  setSessionCookie(req, res, sessionId, expiresAt);
+  return user;
+}
+
+export async function logoutPlatformUser(req: Request, res: Response) {
+  const sid = readCookie(req);
+  if (sid) {
+    await db.update(platformSessions).set({ revokedAt: new Date() }).where(eq(platformSessions.id, sid));
+  }
+  clearSessionCookie(req, res);
+}
+
+export async function loadPlatformUser(req: Request): Promise<PlatformUser | null> {
+  const sid = readCookie(req);
+  if (!sid) return null;
+  const [session] = await db
+    .select()
+    .from(platformSessions)
+    .where(and(eq(platformSessions.id, sid), isNull(platformSessions.revokedAt), gt(platformSessions.expiresAt, new Date())))
+    .limit(1);
+  if (!session) return null;
+  if (Date.now() - session.lastSeenAt.getTime() > IDLE_MS) {
+    await db.update(platformSessions).set({ revokedAt: new Date() }).where(eq(platformSessions.id, sid));
+    return null;
+  }
+  const [user] = await db.select().from(platformUsers).where(eq(platformUsers.id, session.userId)).limit(1);
+  if (!user) return null;
+  await db.update(platformSessions).set({ lastSeenAt: new Date() }).where(eq(platformSessions.id, sid));
+  req.platformSessionId = sid;
+  return user;
+}
+
+export async function platformAuthOptional(req: Request, _res: Response, next: NextFunction) {
+  try {
+    req.platformUser = (await loadPlatformUser(req)) || undefined;
+    next();
+  } catch (e) {
+    next(e);
+  }
+}
+
+export async function requirePlatformUser(req: Request, res: Response, next: NextFunction) {
+  try {
+    const user = await loadPlatformUser(req);
+    if (!user) throw new HttpError(401, 'Connexion requise.');
+    req.platformUser = user;
+    next();
+  } catch (e) {
+    next(e);
+  }
+}
+
+export function requireRole(...roles: PlatformUser['role'][]) {
+  return (req: Request, _res: Response, next: NextFunction) => {
+    const u = req.platformUser;
+    if (!u) return next(new HttpError(401, 'Connexion requise.'));
+    if (!roles.includes(u.role) && u.role !== 'admin') return next(new HttpError(403, 'Accès refusé.'));
+    next();
+  };
+}
+
+export async function createResetToken(userId: string): Promise<string> {
+  const raw = randomToken(32);
+  const { platformAuthTokens } = await import('../db/schema');
+  await db.insert(platformAuthTokens).values({
+    id: crypto.randomUUID(),
+    userId,
+    kind: 'reset',
+    tokenHash: sha256(raw),
+    expiresAt: new Date(Date.now() + 3600_000),
+  });
+  return raw;
+}
+
+export async function consumeResetToken(raw: string, newPassword: string): Promise<void> {
+  const err = validatePlatformPassword(newPassword);
+  if (err) throw new HttpError(422, err);
+  const { platformAuthTokens } = await import('../db/schema');
+  const hash = sha256(raw);
+  const [tok] = await db
+    .select()
+    .from(platformAuthTokens)
+    .where(and(eq(platformAuthTokens.tokenHash, hash), eq(platformAuthTokens.kind, 'reset'), isNull(platformAuthTokens.usedAt), gt(platformAuthTokens.expiresAt, new Date())))
+    .limit(1);
+  if (!tok) throw new HttpError(400, 'Lien de réinitialisation invalide ou expiré.');
+  const { hash: passwordHash, salt } = hashPassword(newPassword);
+  await db.update(platformUsers).set({ passwordHash, salt, updatedAt: new Date() }).where(eq(platformUsers.id, tok.userId));
+  await db.update(platformAuthTokens).set({ usedAt: new Date() }).where(eq(platformAuthTokens.id, tok.id));
+  await db.update(platformSessions).set({ revokedAt: new Date() }).where(eq(platformSessions.userId, tok.userId));
+}

package/template/server/platform/clientWelcome.ts

@@ -0,0 +1,168 @@
+/**
+ * Snapify — création compte client + e-mail de bienvenue (charte Snapify)
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ */
+import crypto from 'crypto';
+import { eq } from 'drizzle-orm';
+import { db } from '../db/client';
+import { platformUsers } from '../db/schema';
+import { escapeHtml, renderEmail, sendMail } from '../mail';
+import { loadSnapshot } from '../cms/store';
+import { createPlatformUser } from './auth';
+import { hashPassword } from './passwords';
+import type { LicenseOrder } from './licenseOrders';
+import type { ClientProfile } from './clients';
+
+function generateClientPassword(): string {
+  const raw = crypto.randomBytes(9).toString('base64url').replace(/[^a-zA-Z0-9]/g, '');
+  // Lettre + chiffre obligatoires (règle plateforme)
+  return `Sf${raw.slice(0, 8)}7`;
+}
+
+export function clientPortalUrl(market: 'tn' | 'fr'): string {
+  if (process.env.CLIENT_PUBLIC_URL) return process.env.CLIENT_PUBLIC_URL.replace(/\/$/, '');
+  // Pas de sous-domaine : espace client sur le domaine principal
+  return market === 'fr' ? 'https://snapify.fr/espace-client' : 'https://snapify.tn/espace-client';
+}
+
+async function snapifyMailBrand() {
+  const s = await loadSnapshot();
+  return {
+    ...s,
+    branding: {
+      ...s.branding,
+      siteName: 'Snapify',
+      colors: { ...(s.branding.colors || {}), primary: '#00a89d' },
+    },
+  };
+}
+
+/** Crée le compte plateforme si besoin ; renvoie le mot de passe en clair uniquement à la création. */
+export async function ensureClientPlatformAccount(order: LicenseOrder): Promise<{
+  userId: string;
+  email: string;
+  password: string | null;
+  created: boolean;
+}> {
+  const email = order.email.trim().toLowerCase();
+  const [existing] = await db.select().from(platformUsers).where(eq(platformUsers.email, email)).limit(1);
+  if (existing) {
+    return { userId: existing.id, email, password: null, created: false };
+  }
+  const password = generateClientPassword();
+  try {
+    const user = await createPlatformUser({
+      email,
+      password,
+      displayName: order.name.slice(0, 80) || email.split('@')[0],
+    });
+    return { userId: user.id, email, password, created: true };
+  } catch (e: unknown) {
+    // Course : compte créé entre-temps
+    const [again] = await db.select().from(platformUsers).where(eq(platformUsers.email, email)).limit(1);
+    if (again) return { userId: again.id, email, password: null, created: false };
+    throw e;
+  }
+}
+
+export async function sendClientWelcomeEmail(opts: {
+  name: string;
+  email: string;
+  password: string | null;
+  domain: string;
+  market: 'tn' | 'fr';
+  created: boolean;
+}): Promise<{ sent: boolean; reason?: string }> {
+  const portal = clientPortalUrl(opts.market);
+  const brand = await snapifyMailBrand();
+  const first = opts.name.trim().split(/\s+/)[0] || 'bonjour';
+
+  const credHtml = opts.created && opts.password
+    ? `<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="margin:18px 0;background:#f0fdfa;border:1px solid #99f6e4;border-radius:12px">
+<tr><td style="padding:16px 18px">
+<p style="margin:0 0 8px;font-size:13px;color:#0f766e;font-weight:700;text-transform:uppercase;letter-spacing:.04em">Vos identifiants</p>
+<p style="margin:0 0 6px;font-size:15px;color:#0f172a"><strong>E-mail :</strong> ${escapeHtml(opts.email)}</p>
+<p style="margin:0;font-size:15px;color:#0f172a"><strong>Mot de passe :</strong> <code style="font-size:15px;background:#fff;padding:4px 8px;border-radius:6px;border:1px solid #ccfbf1">${escapeHtml(opts.password)}</code></p>
+</td></tr></table>`
+    : `<p style="margin:0 0 14px;font-size:15px;line-height:1.6;color:#334155">Connectez-vous avec votre e-mail <strong>${escapeHtml(opts.email)}</strong> et le mot de passe de votre compte Snapify existant.</p>`;
+
+  const { html, text } = renderEmail(brand, {
+    title: opts.created ? 'Bienvenue sur Snapify' : 'Votre demande Snapify est enregistrée',
+    intro: `Bonjour ${first}, merci pour votre demande concernant ${opts.domain}. Votre espace client est prêt : suivez l’avancement du projet, les paiements, les factures et le support.`,
+    lines: opts.created
+      ? [
+          'Conservez cet e-mail : il contient vos identifiants de connexion.',
+          'Vous pourrez changer le mot de passe depuis Mon profil une fois connecté(e).',
+        ]
+      : ['Votre demande a été ajoutée à votre espace client existant.'],
+    html: credHtml,
+    button: { label: 'Accéder à mon espace client', url: portal },
+    outro: 'Besoin d’aide ? Répondez à cet e-mail ou ouvrez un ticket depuis l’espace client. — L’équipe Snapify · NOVALABS',
+  });
+
+  const subject = opts.created
+    ? `Bienvenue sur Snapify — vos accès (${opts.domain})`
+    : `Snapify — demande enregistrée (${opts.domain})`;
+
+  return sendMail({ to: opts.email, subject, html, text, kind: 'invite' });
+}
+
+/**
+ * Après création / màj fiche : provisionne le compte + envoie le mail de bienvenue
+ * (mot de passe en clair uniquement si le compte vient d’être créé).
+ */
+export async function provisionClientAndWelcome(
+  profile: ClientProfile,
+  order: LicenseOrder,
+  opts: { market?: 'tn' | 'fr'; forceWelcome?: boolean } = {}
+): Promise<{ mailed: boolean; createdAccount: boolean }> {
+  const market = opts.market || profile.market || 'tn';
+  const account = await ensureClientPlatformAccount(order);
+
+  // Lier la fiche si besoin
+  if (profile.platformUserId !== account.userId) {
+    const { clientProfiles } = await import('../db/schema');
+    await db
+      .update(clientProfiles)
+      .set({ platformUserId: account.userId, updatedAt: new Date() })
+      .where(eq(clientProfiles.id, profile.id));
+  }
+
+  // Éviter le spam : mail avec MDP seulement à la création ; sinon ack une fois par « première » demande
+  const shouldMail = account.created || opts.forceWelcome || (profile.licenseOrderIds?.length || 0) <= 1;
+  if (!shouldMail) return { mailed: false, createdAccount: account.created };
+
+  // Si compte existant et déjà plus d’une demande, pas de re-mail sauf force
+  if (!account.created && (profile.licenseOrderIds?.length || 0) > 1 && !opts.forceWelcome) {
+    return { mailed: false, createdAccount: false };
+  }
+
+  const result = await sendClientWelcomeEmail({
+    name: order.name || profile.name,
+    email: account.email,
+    password: account.password,
+    domain: order.domain || profile.domain,
+    market,
+    created: account.created,
+  });
+
+  return { mailed: result.sent, createdAccount: account.created };
+}
+
+/** Utilisé si on doit régénérer un MDP (superadmin relance) — non exposé public. */
+export async function resetClientPasswordAndMail(email: string, market: 'tn' | 'fr' = 'tn') {
+  const e = email.trim().toLowerCase();
+  const [user] = await db.select().from(platformUsers).where(eq(platformUsers.email, e)).limit(1);
+  if (!user) throw new Error('Compte introuvable');
+  const password = generateClientPassword();
+  const { hash, salt } = hashPassword(password);
+  await db.update(platformUsers).set({ passwordHash: hash, salt, updatedAt: new Date() }).where(eq(platformUsers.id, user.id));
+  return sendClientWelcomeEmail({
+    name: user.displayName,
+    email: e,
+    password,
+    domain: 'votre projet',
+    market,
+    created: true,
+  });
+}