create-snapify-app 0.0.0-stage → 1.1.1

package/template/server/marketplace/packageValidate.ts

@@ -0,0 +1,475 @@
+/**
+ * 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.
+ */
+/**
+ * Analyse d’un paquet .snapmod / .snaptheme déposé sur la marketplace : structure, empreintes,
+ * signature, licence, compatibilité, puis analyse statique du code (syntaxe, imports, exports,
+ * accès système, cohérence permissions ↔ appels `ctx`, styles, réglages, visuels).
+ * Le code du paquet n’est jamais exécuté : il est analysé par esbuild et par motifs.
+ */
+import crypto from 'crypto';
+import * as esbuild from 'esbuild';
+import { SNAPIFY_MODULE_API_VERSION, type PackagedManifest } from '../../sdk/index';
+import { checkLicensePayload, compareVersions, decodePackage, PackageError, satisfies, verify, type ModulePackage } from '../../sdk/package';
+import { TRUSTED_KEYS } from '../modules/trust';
+
+export type CheckGroup = 'Paquet' | 'Manifeste' | 'Code' | 'Permissions' | 'Sécurité' | 'Présentation' | 'Marketplace';
+
+export type ValidationCheck = {
+  id: string;
+  label: string;
+  status: 'pass' | 'fail' | 'warn';
+  detail?: string;
+  group?: CheckGroup;
+};
+
+export type PackageValidationResult = {
+  ok: boolean;
+  checks: ValidationCheck[];
+  manifest?: ModulePackage['manifest'];
+  signed: boolean;
+  signatureKid?: string;
+  hasLicense: boolean;
+  fileCount: number;
+  size: number;
+  sha256: string;
+  errors: string[];
+  warnings: string[];
+  /** Capacités `ctx` détectées dans server.mjs, pour la revue. */
+  analysis?: { capabilities: string[]; envVars: string[]; hosts: string[]; files: { name: string; size: number }[] };
+};
+
+const hashBuf = (buf: Buffer) => crypto.createHash('sha256').update(buf).digest('hex');
+const kb = (n: number) => `${(n / 1024).toFixed(1)} Ko`;
+
+class Report {
+  checks: ValidationCheck[] = [];
+  errors: string[] = [];
+  warnings: string[] = [];
+  constructor(private group: CheckGroup = 'Paquet') {}
+  in(group: CheckGroup) {
+    this.group = group;
+    return this;
+  }
+  pass(id: string, label: string, detail?: string) {
+    this.checks.push({ id, label, status: 'pass', detail, group: this.group });
+  }
+  warn(id: string, label: string, detail: string) {
+    this.checks.push({ id, label, status: 'warn', detail, group: this.group });
+    this.warnings.push(`${label} : ${detail}`);
+  }
+  fail(id: string, label: string, detail: string) {
+    this.checks.push({ id, label, status: 'fail', detail, group: this.group });
+    this.errors.push(`${label} : ${detail}`);
+  }
+}
+
+/* ------------------------------------------------------------------ Code */
+
+/** Modules Node sans accès au système, déjà utilisés par les modules officiels. */
+const NODE_ALLOWED = new Set(['crypto', 'util', 'url', 'buffer', 'events', 'string_decoder', 'querystring', 'path', 'assert']);
+/** Accès au disque, aux processus, au réseau brut ou au moteur : contournent les permissions. */
+const NODE_FORBIDDEN = new Set([
+  'fs', 'fs/promises', 'child_process', 'net', 'tls', 'dgram', 'dns', 'http', 'https', 'http2', 'os', 'cluster', 'worker_threads',
+  'vm', 'v8', 'module', 'inspector', 'process', 'repl', 'readline', 'perf_hooks', 'async_hooks', 'diagnostics_channel', 'wasi', 'trace_events',
+]);
+
+type CodeInfo = { imports: { path: string; kind: string }[]; exports: string[] };
+
+async function parseBundle(code: string, name: string): Promise<CodeInfo | { error: string }> {
+  try {
+    const r = await esbuild.build({
+      stdin: { contents: code, loader: 'js', sourcefile: name },
+      bundle: true,
+      write: false,
+      metafile: true,
+      format: 'esm',
+      platform: 'neutral',
+      external: ['*'],
+      logLevel: 'silent',
+    });
+    const input = r.metafile.inputs[name];
+    const output = Object.values(r.metafile.outputs)[0];
+    return { imports: (input?.imports || []).map((i) => ({ path: i.path, kind: i.kind })), exports: output?.exports || [] };
+  } catch (e) {
+    const errs = (e as { errors?: { text: string; location?: { line: number; column: number } | null }[] }).errors;
+    const first = errs?.[0];
+    return { error: first ? `${first.text}${first.location ? ` (ligne ${first.location.line}, col. ${first.location.column})` : ''}` : 'syntaxe invalide' };
+  }
+}
+
+/** Capacité `ctx` → permission requise. */
+const CAPABILITIES: { re: RegExp; cap: string; perm: string | ((m: PackagedManifest) => boolean) }[] = [
+  { re: /\.http\.(?:get|post)\(/, cap: 'ctx.http (routes publiques)', perm: 'http:routes' },
+  { re: /\.db\.collection\(/, cap: 'ctx.db (collections)', perm: 'database' },
+  { re: /\.storage\.(?:get|set|delete)\(/, cap: 'ctx.storage', perm: 'storage' },
+  { re: /\.files\.(?:saveImage|delete)\(/, cap: 'ctx.files', perm: 'files' },
+  { re: /\.mail\.send\(/, cap: 'ctx.mail.send', perm: 'mail:send' },
+  { re: /\.site\(\)/, cap: 'ctx.site()', perm: 'site:read' },
+  { re: /\.admin\.(?:get|post|put|delete)\(/, cap: 'ctx.admin (routes d’administration)', perm: 'admin:routes' },
+  { re: /\.fetch\(/, cap: 'ctx.fetch (réseau)', perm: (m) => m.permissions.some((p) => p.startsWith('net:')) },
+  { re: /\.ftp\.(?:list|readText)\(/, cap: 'ctx.ftp', perm: 'net:ftp' },
+];
+
+function analyzeServer(code: string, m: PackagedManifest, r: Report) {
+  const declared = new Set(m.permissions);
+  const capabilities: string[] = [];
+  const used = new Set<string>();
+
+  r.in('Permissions');
+  for (const c of CAPABILITIES) {
+    if (!c.re.test(code)) continue;
+    capabilities.push(c.cap);
+    const ok = typeof c.perm === 'string' ? declared.has(c.perm as never) : c.perm(m);
+    const permLabel = typeof c.perm === 'string' ? c.perm : 'net:<hôte>';
+    if (typeof c.perm === 'string') used.add(c.perm);
+    if (ok) r.pass(`cap-${permLabel}`, `${c.cap}`, `permission ${permLabel} déclarée`);
+    else r.fail(`cap-${permLabel}`, `${c.cap}`, `utilisé sans la permission ${permLabel} : l’appel échouera sur le site`);
+  }
+
+  const envVars = [...new Set([...code.matchAll(/\.env\(\s*["'`]([A-Za-z0-9_]+)["'`]\s*\)/g)].map((x) => x[1]))];
+  for (const v of envVars) {
+    used.add(`env:${v}`);
+    if (declared.has(`env:${v}` as never)) r.pass(`env-${v}`, `Variable ${v}`, `permission env:${v} déclarée`);
+    else r.fail(`env-${v}`, `Variable ${v}`, `lue avec ctx.env() sans la permission env:${v}`);
+  }
+  if (/\.env\(\s*[^"'`\s)]/.test(code)) r.warn('env-dynamic', 'Variables d’environnement', 'nom calculé à l’exécution : seules les variables déclarées dans les permissions seront lisibles');
+
+  const hostsInCode = [...new Set([...code.matchAll(/https:\/\/([a-z0-9-]+(?:\.[a-z0-9-]+)+)/gi)].map((x) => x[1].toLowerCase()))];
+  const netHosts = m.permissions.filter((p) => p.startsWith('net:')).map((p) => p.slice(4));
+  for (const h of netHosts) {
+    if (hostsInCode.includes(h)) used.add(`net:${h}`);
+  }
+  const undeclaredHosts = /\.fetch\(/.test(code) ? hostsInCode.filter((h) => !netHosts.includes(h)) : [];
+  if (undeclaredHosts.length) {
+    r.warn('net-undeclared', 'Adresses externes', `${undeclaredHosts.join(', ')} apparaissent dans le code sans permission net: — ctx.fetch() les refusera`);
+  }
+
+  const unused = m.permissions.filter(
+    (p) =>
+      !used.has(p) &&
+      p !== 'http:cookies' &&
+      !(p === 'net:outbound' && /\.fetch\(/.test(code)) &&
+      !(p === 'net:ftp' && /\.ftp\.(?:list|readText)\(/.test(code)) &&
+      !(p.startsWith('net:') && p !== 'net:outbound' && p !== 'net:ftp' && !hostsInCode.length && /\.fetch\(/.test(code))
+  );
+  if (unused.length) r.warn('perm-unused', 'Permissions non utilisées', `${unused.join(', ')} : retirez-les si elles ne servent pas, elles sont affichées au client`);
+  else if (m.permissions.length) r.pass('perm-unused', 'Permissions minimales', 'toutes les permissions déclarées sont utilisées');
+  if (declared.has('http:cookies') && !/\.http\.reply\(/.test(code) && !/cookies/.test(code)) {
+    r.warn('perm-cookies', 'Permission http:cookies', 'déclarée mais aucun cookie lu ni déposé');
+  }
+
+  r.in('Sécurité');
+  const rules: [RegExp, string, string][] = [
+    [/\bprocess\.env\b/, 'process.env', 'lecture directe des variables du serveur : utilisez ctx.env() et la permission env:'],
+    [/\bprocess\.(?:exit|kill|binding|dlopen|chdir|setuid)\b/, 'process', 'contrôle du processus du site'],
+    [/(?:^|[^\w$.])require\s*\(|createRequire\s*\(/, 'require()', 'chargement de modules Node hors bundle'],
+    [/(?:^|[^\w$.])fetch\s*\(|globalThis\.fetch\b|\bXMLHttpRequest\b|\bnew\s+WebSocket\b/, 'Réseau direct', 'appel réseau qui contourne ctx.fetch() et les permissions net:'],
+    [/(?:^|[^\w$.])eval\s*\(|new\s+Function\s*\(/, 'eval / new Function', 'exécution de code construit à l’exécution'],
+    [/\bglobalThis\.__SNAPIFY|\b__dirname\b|\bimport\.meta\.url\b/, 'Accès à l’hôte', 'accès aux internes du CMS ou au système de fichiers'],
+  ];
+  let clean = true;
+  for (const [re, label, detail] of rules) {
+    if (re.test(code)) {
+      clean = false;
+      r.fail(`srv-${label}`, `Serveur : ${label}`, detail);
+    }
+  }
+  if (clean) r.pass('srv-clean', 'Code serveur', 'aucun accès direct au système, au réseau ni aux internes du CMS');
+
+  return { capabilities, envVars, hosts: hostsInCode };
+}
+
+function analyzeBrowser(code: string, name: string, r: Report) {
+  r.in('Sécurité');
+  const issues: string[] = [];
+  if (/(?:^|[^\w$.])eval\s*\(|new\s+Function\s*\(/.test(code)) issues.push('eval / new Function');
+  if (/\bdocument\.cookie\b/.test(code)) issues.push('lecture de document.cookie');
+  if (/localStorage\.(?:getItem|setItem)\(\s*["'`](?:snapify_admin|admin_token|px_admin)/.test(code)) issues.push('accès à la session d’administration');
+  if (/<script[\s>]|\.src\s*=\s*["'`]https?:\/\//.test(code) && /createElement\(\s*["'`]script["'`]\)/.test(code)) issues.push('injection de scripts externes');
+  if (issues.length) r.warn(`br-${name}`, `${name} : pratiques à justifier`, issues.join(', '));
+  else r.pass(`br-${name}`, `${name} : code navigateur`, 'aucune pratique à risque détectée');
+}
+
+/** Clés présentes dans un bundle minifié (les noms de propriétés ne sont pas renommés). */
+const hasKey = (code: string, key: string) => new RegExp(`(?:["'\`]${key.replace(/[-.]/g, '\\$&')}["'\`]|[{,]\\s*${/^[A-Za-z_$][\w$]*$/.test(key) ? key : '\\0'})\\s*:`).test(code);
+
+function analyzeShape(m: PackagedManifest, files: Map<string, Buffer>, r: Report) {
+  r.in('Code');
+  const pub = files.get('public.js')?.toString('utf8') || '';
+  const admin = files.get('admin.js')?.toString('utf8') || '';
+  if (m.kind === 'theme') {
+    const missing = ['Header', 'Footer', 'blocks'].filter((k) => !hasKey(pub, k));
+    if (missing.length) r.fail('theme-contract', 'Contrat du thème', `defineTheme sans ${missing.join(', ')} : le site ne pourrait pas s’afficher`);
+    else r.pass('theme-contract', 'Contrat du thème', 'Header, Footer et blocks fournis');
+    return;
+  }
+  const missing: string[] = [];
+  for (const s of m.slots) if (!hasKey(pub, s)) missing.push(`emplacement « ${s} »`);
+  if (m.routes?.length && !hasKey(pub, 'page')) missing.push('composant page (routes déclarées)');
+  for (const w of m.widgets || []) if (!hasKey(pub, w.id)) missing.push(`widget « ${w.id} »`);
+  for (const p of m.adminPages || []) if (!hasKey(admin, p.id)) missing.push(`page d’administration « ${p.id} »`);
+  const declaredCount = m.slots.length + (m.routes?.length ? 1 : 0) + (m.widgets?.length || 0) + (m.adminPages?.length || 0);
+  if (missing.length) r.warn('shape', 'Composants déclarés', `introuvables dans le code : ${missing.join(', ')}`);
+  else if (declaredCount) r.pass('shape', 'Composants déclarés', `${declaredCount} élément(s) du manifeste trouvés dans le code`);
+}
+
+async function analyzeCss(m: PackagedManifest, files: Map<string, Buffer>, r: Report) {
+  r.in('Sécurité');
+  const { default: postcss } = await import('postcss');
+  for (const name of ['public.css', 'admin.css']) {
+    const css = files.get(name);
+    if (!css) continue;
+    let root;
+    try {
+      root = postcss.parse(css.toString('utf8'));
+    } catch (e) {
+      r.fail(`css-${name}`, `${name}`, `feuille de style illisible : ${(e as Error).message.slice(0, 120)}`);
+      continue;
+    }
+    const remote: string[] = [];
+    root.walkAtRules('import', (a) => {
+      if (/https?:/.test(a.params)) remote.push(a.params.slice(0, 80));
+    });
+    if (m.kind === 'theme') {
+      if (remote.length) r.warn(`css-${name}`, `${name}`, `ressources externes importées : ${remote.join(', ')}`);
+      else r.pass(`css-${name}`, `${name}`, 'feuille globale du thème');
+      continue;
+    }
+    const scope = `:where([data-snapify-scope="${m.id}"])`;
+    const leaks: string[] = [];
+    root.walkRules((rule) => {
+      const parent = rule.parent as { type?: string; name?: string } | undefined;
+      if (parent?.type === 'atrule' && /keyframes$/i.test(parent.name || '')) return;
+      for (const s of rule.selectors) {
+        const t = s.trim();
+        const rooted = /^(:root|:host|html|body)\b/.test(t) && t.includes(scope);
+        if (!t.startsWith(scope) && !rooted && !/^(:root|:host)$/.test(t)) leaks.push(t);
+      }
+    });
+    if (leaks.length) r.fail(`css-${name}`, `${name} : portée des styles`, `${leaks.length} sélecteur(s) hors du conteneur du module (ex. ${leaks.slice(0, 3).join(' · ')}) : il modifierait le thème du site`);
+    else if (remote.length) r.warn(`css-${name}`, `${name}`, `ressources externes importées : ${remote.join(', ')}`);
+    else r.pass(`css-${name}`, `${name} : portée des styles`, 'toutes les règles sont limitées au conteneur du module');
+  }
+}
+
+/* ------------------------------------------------------------------ Présentation */
+
+function imageSize(buf: Buffer): { type: string; width: number; height: number } | null {
+  if (buf.length > 24 && buf.readUInt32BE(0) === 0x89504e47) return { type: 'png', width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+  if (buf.length > 4 && buf[0] === 0xff && buf[1] === 0xd8) {
+    let i = 2;
+    while (i + 9 < buf.length) {
+      if (buf[i] !== 0xff) return null;
+      const marker = buf[i + 1];
+      const len = buf.readUInt16BE(i + 2);
+      if (marker >= 0xc0 && marker <= 0xcf && ![0xc4, 0xc8, 0xcc].includes(marker)) return { type: 'jpg', height: buf.readUInt16BE(i + 5), width: buf.readUInt16BE(i + 7) };
+      i += 2 + len;
+    }
+    return null;
+  }
+  if (buf.length > 30 && buf.toString('ascii', 0, 4) === 'RIFF' && buf.toString('ascii', 8, 12) === 'WEBP') {
+    const chunk = buf.toString('ascii', 12, 16);
+    if (chunk === 'VP8 ') return { type: 'webp', width: buf.readUInt16LE(26) & 0x3fff, height: buf.readUInt16LE(28) & 0x3fff };
+    if (chunk === 'VP8L') {
+      const b = buf.readUInt32LE(21);
+      return { type: 'webp', width: (b & 0x3fff) + 1, height: ((b >> 14) & 0x3fff) + 1 };
+    }
+    if (chunk === 'VP8X') return { type: 'webp', width: buf.readUIntLE(24, 3) + 1, height: buf.readUIntLE(27, 3) + 1 };
+  }
+  return null;
+}
+
+const SECRET_KEY = /(secret|token|password|passwd|pwd|api_?key|private_?key|access_?key|client_?secret)$/i;
+
+function analyzePresentation(m: PackagedManifest, files: Map<string, Buffer>, r: Report) {
+  r.in('Sécurité');
+  const exposed = [...m.settings, ...(m.widgets || []).flatMap((w) => w.fields)].filter((f) => SECRET_KEY.test(f.key) && (f.public || m.kind === 'theme'));
+  if (exposed.length) r.fail('settings-secret', 'Réglages publics', `${exposed.map((f) => f.key).join(', ')} ressemble à un secret mais serait envoyé au navigateur`);
+  else r.pass('settings-secret', 'Réglages publics', `${m.settings.filter((f) => f.public).length} réglage(s) public(s), aucun secret exposé`);
+
+  r.in('Présentation');
+  const shot = m.screenshot ? files.get(m.screenshot) : undefined;
+  if (!shot) r.warn('screenshot', 'Capture d’écran', 'absente : ajoutez "screenshot" au manifeste (1280 × 720 conseillé)');
+  else {
+    const dim = imageSize(shot);
+    const ext = m.screenshot!.split('.').pop();
+    if (!dim) r.fail('screenshot', 'Capture d’écran', 'fichier image illisible');
+    else if (dim.type !== ext) r.fail('screenshot', 'Capture d’écran', `le contenu (${dim.type}) ne correspond pas à l’extension .${ext}`);
+    else if (dim.width < 800 || dim.height < 450) r.warn('screenshot', 'Capture d’écran', `${dim.width} × ${dim.height} : trop petite pour la marketplace (1280 × 720 conseillé)`);
+    else r.pass('screenshot', 'Capture d’écran', `${dim.width} × ${dim.height}, ${kb(shot.length)}`);
+  }
+  if (files.has('README.md')) r.pass('readme', 'README', kb(files.get('README.md')!.length));
+  else r.warn('readme', 'README', 'absent : décrivez l’installation et les réglages pour les clients');
+  if (m.description.trim().length < 40) r.warn('description', 'Description', 'moins de 40 caractères : elle sert de résumé sur la marketplace');
+}
+
+/* ------------------------------------------------------------------ Analyse */
+
+const BUNDLE_LIMITS: Record<string, number> = { 'public.js': 900 * 1024, 'admin.js': 1.5 * 1024 * 1024, 'server.mjs': 2 * 1024 * 1024 };
+
+/** Analyse complète d’un paquet .snapmod / .snaptheme (structure, empreintes, signature, code, cohérence). */
+export async function validateMarketplacePackage(
+  buf: Buffer,
+  opts?: { expectedKind?: 'module' | 'theme'; expectedModuleId?: string; expectedVersion?: string }
+): Promise<PackageValidationResult> {
+  const r = new Report('Paquet');
+  const size = buf.length;
+  const digest = hashBuf(buf);
+  const result = (extra: Partial<PackageValidationResult> = {}): PackageValidationResult => ({
+    ok: r.errors.length === 0,
+    checks: r.checks,
+    signed: false,
+    hasLicense: false,
+    fileCount: 0,
+    size,
+    sha256: digest,
+    errors: r.errors,
+    warnings: r.warnings,
+    ...extra,
+  });
+
+  if (size <= 0 || size > 20 * 1024 * 1024) r.fail('size', 'Taille du fichier', `${kb(size)} — 20 Mo maximum`);
+  else r.pass('size', 'Taille du fichier', kb(size));
+
+  let pkg: ModulePackage;
+  let files: Map<string, Buffer>;
+  try {
+    ({ pkg, files } = decodePackage(buf));
+  } catch (e) {
+    r.fail('format', 'Format et manifeste', e instanceof PackageError ? e.message : 'Paquet illisible');
+    return result();
+  }
+  const m = pkg.manifest;
+  const kind = m.kind === 'theme' ? 'theme' : 'module';
+  r.pass('format', 'Format snapmod/1', `${files.size} fichier(s) : ${[...files.keys()].join(', ')}`);
+  r.pass('integrity', 'Empreintes SHA-256', 'chaque fichier correspond au manifeste');
+
+  const signed = verify(m, pkg.signature, TRUSTED_KEYS);
+  if (signed) r.pass('signature', 'Signature NOVALABS', pkg.signature?.kid);
+  else if (pkg.signature?.kid && TRUSTED_KEYS[pkg.signature.kid]) r.fail('signature', 'Signature', 'ne correspond plus au contenu : le paquet a été modifié après sa signature');
+  else if (pkg.signature) r.warn('signature', 'Signature', 'présente mais d’une clé non reconnue : NOVALABS signera la version validée');
+  else r.warn('signature', 'Signature', 'paquet non signé : NOVALABS signera la version validée lors de la revue');
+
+  const lic = pkg.license;
+  if (lic) {
+    const issues = checkLicensePayload(lic.payload);
+    if (!verify(lic.payload, lic.signature, TRUSTED_KEYS)) r.fail('license', 'Licence embarquée', 'signature de licence invalide');
+    else if (lic.payload.moduleId !== m.id) r.fail('license', 'Licence embarquée', `délivrée pour ${lic.payload.moduleId}, pas pour ${m.id}`);
+    else if (issues.length) r.fail('license', 'Licence embarquée', issues.join(', '));
+    else if (lic.payload.expiresAt && Date.parse(lic.payload.expiresAt) < Date.now()) r.fail('license', 'Licence embarquée', 'expirée');
+    else if (m.pricing === 'paid' && lic.payload.domains.includes('*')) r.warn('license', 'Licence embarquée', 'module payant livré avec une licence valable partout : il serait utilisable sans achat');
+    else r.pass('license', 'Licence embarquée', `${lic.payload.plan}, ${lic.payload.domains.join(', ')}`);
+  } else {
+    r.pass('license', 'Licence', m.pricing === 'paid' ? 'délivrée au client à chaque achat' : 'licence gratuite ajoutée à la signature');
+  }
+
+  r.in('Manifeste');
+  r.pass('manifest', 'Manifeste', `${m.id}@${m.version} — ${kind === 'theme' ? 'thème' : 'module'} « ${m.name} »`);
+  if (opts?.expectedKind && opts.expectedKind !== kind) r.fail('kind', 'Type', `attendu : ${opts.expectedKind === 'theme' ? 'thème' : 'module'}, reçu : ${kind === 'theme' ? 'thème' : 'module'}`);
+  if (opts?.expectedModuleId && opts.expectedModuleId !== m.id) r.fail('id', 'Identifiant', `${m.id} ≠ ${opts.expectedModuleId} : une mise à jour doit garder le même identifiant`);
+  if (opts?.expectedVersion && opts.expectedVersion !== m.version) r.warn('version', 'Version', `manifeste ${m.version} ≠ version saisie ${opts.expectedVersion} — celle du manifeste est utilisée`);
+
+  const range = m.engines.snapify;
+  if (!/^(\*|(\^|>=)?\d+\.\d+\.\d+)$/.test(range.trim())) r.fail('engines', 'Compatibilité Snapify', `plage « ${range} » non reconnue (ex. ^1.3.0)`);
+  else if (!satisfies(SNAPIFY_MODULE_API_VERSION, range)) r.fail('engines', 'Compatibilité Snapify', `requiert ${range}, l’API actuelle est ${SNAPIFY_MODULE_API_VERSION} : installation refusée par les sites`);
+  else if (range.trim() === '*') r.warn('engines', 'Compatibilité Snapify', `« * » : précisez la version minimale testée (ex. ^${SNAPIFY_MODULE_API_VERSION})`);
+  else r.pass('engines', 'Compatibilité Snapify', `${range} — compatible avec l’API ${SNAPIFY_MODULE_API_VERSION}`);
+
+  if (m.requires && Object.keys(m.requires).length) {
+    r.pass('requires', 'Dépendances', Object.entries(m.requires).map(([id, v]) => `${id} ${v}`).join(', '));
+  }
+
+  r.in('Code');
+  const fileStats: { name: string; size: number }[] = [];
+  let srv: ReturnType<typeof analyzeServer> | undefined;
+  for (const name of ['public.js', 'admin.js', 'server.mjs'] as const) {
+    const data = files.get(name);
+    if (!data) continue;
+    fileStats.push({ name, size: data.length });
+    const code = data.toString('utf8');
+    const info = await parseBundle(code, name);
+    if ('error' in info) {
+      r.fail(`syntax-${name}`, `${name} : syntaxe`, info.error);
+      continue;
+    }
+    if (!info.exports.includes('default')) {
+      r.fail(`export-${name}`, `${name} : export`, 'pas d’export par défaut (definePublicModule / defineServerModule / defineAdminModule / defineTheme)');
+      continue;
+    }
+    const bad: string[] = [];
+    const forbidden: string[] = [];
+    for (const imp of info.imports) {
+      const spec = imp.path.replace(/^node:/, '');
+      if (imp.kind === 'dynamic-import' || imp.kind === 'require-call') forbidden.push(`${imp.kind === 'dynamic-import' ? 'import()' : 'require'} « ${imp.path} »`);
+      else if (name !== 'server.mjs') bad.push(imp.path);
+      else if (NODE_FORBIDDEN.has(spec)) forbidden.push(imp.path);
+      else if (!NODE_ALLOWED.has(spec)) bad.push(imp.path);
+    }
+    if (forbidden.length) r.fail(`imports-${name}`, `${name} : imports`, `accès interdit : ${forbidden.join(', ')}`);
+    else if (bad.length) r.fail(`imports-${name}`, `${name} : imports`, `${bad.join(', ')} non inclus dans le bundle : le module ne se chargera pas`);
+    else {
+      const node = info.imports.map((i) => i.path);
+      r.pass(`imports-${name}`, `${name}`, `syntaxe valide, export par défaut, ${node.length ? `imports autorisés : ${node.join(', ')}` : 'aucune dépendance externe'} — ${kb(data.length)}`);
+    }
+    if (data.length > BUNDLE_LIMITS[name]) r.warn(`weight-${name}`, `${name} : poids`, `${kb(data.length)} : allège le chargement des pages (limite conseillée ${kb(BUNDLE_LIMITS[name])})`);
+
+    if (name === 'server.mjs') {
+      srv = analyzeServer(code, m, r);
+      r.in('Code');
+    } else {
+      analyzeBrowser(code, name, r);
+      r.in('Code');
+    }
+  }
+  if (!files.has('server.mjs') && m.permissions.length) {
+    r.in('Permissions').warn('perm-noserver', 'Permissions', `${m.permissions.join(', ')} déclarées sans code serveur : elles ne servent à rien`);
+  }
+
+  analyzeShape(m, files, r);
+  await analyzeCss(m, files, r);
+  analyzePresentation(m, files, r);
+
+  return result({
+    manifest: m,
+    signed,
+    signatureKid: signed ? pkg.signature?.kid : undefined,
+    hasLicense: Boolean(lic),
+    fileCount: files.size,
+    analysis: { capabilities: srv?.capabilities || [], envVars: srv?.envVars || [], hosts: srv?.hosts || [], files: fileStats.map((f) => ({ name: f.name, size: f.size })) },
+  });
+}
+
+/** Contrôles qui dépendent de la marketplace (propriété de l’identifiant, version suivante). */
+export function addMarketplaceChecks(
+  report: PackageValidationResult,
+  ctx: {
+    /** Produit visé par une nouvelle version. */
+    product?: { moduleId: string; latestVersion: string | null };
+    /** Identifiant déjà publié par un autre éditeur, ou par cet éditeur dans un autre produit. */
+    takenBy?: 'other' | 'self' | null;
+    reservedPrefix?: boolean;
+  }
+): PackageValidationResult {
+  const m = report.manifest;
+  if (!m) return report;
+  const r = new Report('Marketplace');
+  if (ctx.reservedPrefix) r.fail('id-reserved', 'Identifiant', `le préfixe « ${m.id.split('.')[0]}. » est réservé aux extensions officielles : utilisez le nom de votre société (ex. monagence.${m.id.split('.').pop()})`);
+  if (ctx.takenBy === 'other') r.fail('id-taken', 'Identifiant', `${m.id} appartient déjà à un autre éditeur`);
+  if (ctx.takenBy === 'self') r.fail('id-taken', 'Identifiant', `${m.id} existe déjà dans votre espace : publiez une nouvelle version depuis la fiche du produit`);
+  if (ctx.product) {
+    if (ctx.product.moduleId !== m.id) r.fail('id-match', 'Identifiant', `${m.id} ≠ ${ctx.product.moduleId} : une mise à jour doit garder l’identifiant du produit`);
+    else r.pass('id-match', 'Identifiant', `${m.id} — même produit`);
+    const latest = ctx.product.latestVersion;
+    if (latest && compareVersions(m.version, latest) <= 0) r.fail('version-next', 'Version', `${m.version} doit être supérieure à la dernière version publiée (${latest})`);
+    else r.pass('version-next', 'Version', latest ? `${latest} → ${m.version}` : `première version ${m.version}`);
+  } else if (!ctx.reservedPrefix && !ctx.takenBy) {
+    r.pass('id-free', 'Identifiant', `${m.id} disponible`);
+  }
+  const checks = [...report.checks, ...r.checks];
+  const errors = [...report.errors, ...r.errors];
+  return { ...report, checks, errors, warnings: [...report.warnings, ...r.warnings], ok: errors.length === 0 };
+}

package/template/server/marketplace/payments.ts

@@ -0,0 +1,193 @@
+/**
+ * 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 { and, eq, inArray, sql } from 'drizzle-orm';
+import { db } from '../db/client';
+import {
+  mpDownloads,
+  mpOrderItems,
+  mpOrders,
+  mpProducts,
+  mpPublishers,
+  mpVersions,
+  platformUsers,
+} from '../db/schema';
+import { HttpError } from '../http';
+import { randomToken } from '../security/secrets';
+import { flouciMockAllowed, generatePayment } from '../platform/flouci';
+import { getMpSettings } from '../platform/settings';
+
+function marketplacePublicUrl(): string {
+  const raw =
+    process.env.MARKETPLACE_PUBLIC_URL ||
+    process.env.PLATFORM_PUBLIC_URL ||
+    'http://marketplace.localhost:3000';
+  return raw.replace(/\/$/, '').replace(/\/api\/.*$/, '');
+}
+
+function webhookUrl(): string {
+  return `${marketplacePublicUrl()}/api/platform/flouci/webhook`;
+}
+
+export async function fulfillOrderPayment(orderId: string, flouciPaymentId: string) {
+  const [order] = await db.select().from(mpOrders).where(eq(mpOrders.id, orderId)).limit(1);
+  if (!order) return;
+  if (order.status === 'paid') return;
+
+  await db
+    .update(mpOrders)
+    .set({ status: 'paid', flouciPaymentId, paidAt: new Date() })
+    .where(eq(mpOrders.id, orderId));
+
+  const items = await db.select().from(mpOrderItems).where(eq(mpOrderItems.orderId, orderId));
+  for (const item of items) {
+    await db.insert(mpDownloads).values({
+      id: crypto.randomUUID(),
+      orderItemId: item.id,
+      token: randomToken(24),
+      expiresAt: new Date(Date.now() + 365 * 86400_000),
+    });
+    await db
+      .update(mpProducts)
+      .set({ salesCount: sql`${mpProducts.salesCount} + 1`, updatedAt: new Date() })
+      .where(eq(mpProducts.id, item.productId));
+  }
+}
+
+export async function fulfillPublisherPayment(publisherId: string, flouciPaymentId: string) {
+  const [pub] = await db.select().from(mpPublishers).where(eq(mpPublishers.id, publisherId)).limit(1);
+  if (!pub) return;
+  if (pub.status === 'active') return;
+
+  await db
+    .update(mpPublishers)
+    .set({ status: 'active', paidAt: new Date(), flouciPaymentId })
+    .where(eq(mpPublishers.id, publisherId));
+
+  await db
+    .update(platformUsers)
+    .set({ role: 'publisher', updatedAt: new Date() })
+    .where(and(eq(platformUsers.id, pub.userId), inArray(platformUsers.role, ['member'])));
+}
+
+export async function startOrderCheckout(orderId: string, buyerId: string) {
+  const [order] = await db.select().from(mpOrders).where(and(eq(mpOrders.id, orderId), eq(mpOrders.buyerId, buyerId))).limit(1);
+  if (!order) throw new HttpError(404, 'Commande introuvable');
+  if (order.status === 'paid') throw new HttpError(400, 'Commande déjà payée');
+
+  const trackingId = `order_${order.id}`;
+  const base = marketplacePublicUrl();
+  const payment = await generatePayment({
+    amountMillimes: order.totalMillimes,
+    trackingId,
+    successLink: `${base}/checkout/success?order=${order.id}`,
+    failLink: `${base}/checkout/fail?order=${order.id}`,
+    webhook: webhookUrl(),
+  });
+
+  await db
+    .update(mpOrders)
+    .set({ flouciPaymentId: payment.paymentId, flouciTrackingId: trackingId })
+    .where(eq(mpOrders.id, order.id));
+
+  // Auto-complete en mock (dev uniquement)
+  if (flouciMockAllowed() || (payment.paymentId.startsWith('mock_') && process.env.NODE_ENV !== 'production')) {
+    await fulfillOrderPayment(order.id, payment.paymentId);
+  }
+
+  return payment;
+}
+
+export async function startPublisherFeeCheckout(publisherId: string, userId: string) {
+  const [pub] = await db
+    .select()
+    .from(mpPublishers)
+    .where(and(eq(mpPublishers.id, publisherId), eq(mpPublishers.userId, userId)))
+    .limit(1);
+  if (!pub) throw new HttpError(404, 'Inscription développeur introuvable');
+  if (pub.status === 'active') throw new HttpError(400, 'Déjà inscrit');
+
+  const settings = await getMpSettings();
+  const trackingId = `publisher_${pub.id}`;
+  const base = marketplacePublicUrl();
+  const payment = await generatePayment({
+    amountMillimes: settings.developerFeeMillimes,
+    trackingId,
+    successLink: `${base}/developer/register/success?publisher=${pub.id}`,
+    failLink: `${base}/developer/register?fail=1`,
+    webhook: webhookUrl(),
+  });
+
+  await db.update(mpPublishers).set({ flouciPaymentId: payment.paymentId }).where(eq(mpPublishers.id, pub.id));
+
+  if (flouciMockAllowed() || (payment.paymentId.startsWith('mock_') && process.env.NODE_ENV !== 'production')) {
+    await fulfillPublisherPayment(pub.id, payment.paymentId);
+  }
+
+  return payment;
+}
+
+export async function createOrderFromProducts(buyerId: string, productIds: string[]) {
+  const unique = [...new Set(productIds)];
+  if (!unique.length) throw new HttpError(422, 'Panier vide');
+
+  const products = await db.select().from(mpProducts).where(and(eq(mpProducts.status, 'published'), inArray(mpProducts.id, unique)));
+  if (products.length !== unique.length) throw new HttpError(422, 'Certains produits sont indisponibles');
+
+  const versions = await db.select().from(mpVersions).where(inArray(mpVersions.productId, unique));
+  const latestByProduct = new Map<string, (typeof versions)[0]>();
+  for (const v of versions) {
+    const cur = latestByProduct.get(v.productId);
+    if (!cur || v.createdAt > cur.createdAt) latestByProduct.set(v.productId, v);
+  }
+
+  for (const p of products) {
+    if (!latestByProduct.has(p.id)) throw new HttpError(422, `Aucune version pour ${p.name}`);
+  }
+
+  const settings = await getMpSettings();
+  const totalMillimes = products.reduce((s, p) => s + p.priceMillimes, 0);
+  const commissionMillimes = Math.round((totalMillimes * settings.commissionBps) / 10_000);
+
+  // Gratuit : fulfillment immédiat
+  const orderId = crypto.randomUUID();
+  await db.insert(mpOrders).values({
+    id: orderId,
+    buyerId,
+    totalMillimes,
+    commissionMillimes,
+    status: totalMillimes === 0 ? 'paid' : 'pending',
+    paidAt: totalMillimes === 0 ? new Date() : null,
+  });
+
+  for (const p of products) {
+    const ver = latestByProduct.get(p.id)!;
+    const itemId = crypto.randomUUID();
+    await db.insert(mpOrderItems).values({
+      id: itemId,
+      orderId,
+      productId: p.id,
+      versionId: ver.id,
+      unitPriceMillimes: p.priceMillimes,
+      licenseKey: `SNAP-${randomToken(8).toUpperCase()}`,
+    });
+    if (totalMillimes === 0) {
+      await db.insert(mpDownloads).values({
+        id: crypto.randomUUID(),
+        orderItemId: itemId,
+        token: randomToken(24),
+        expiresAt: new Date(Date.now() + 365 * 86400_000),
+      });
+      await db
+        .update(mpProducts)
+        .set({ salesCount: sql`${mpProducts.salesCount} + 1`, updatedAt: new Date() })
+        .where(eq(mpProducts.id, p.id));
+    }
+  }
+
+  return orderId;
+}