@inwink-mcp/backoffice-extension-helpers 1.0.0

package/README.md

@@ -0,0 +1,96 @@
+# @inwink-mcp/backoffice-extension-helpers
+
+CLI pour **bootstrapper**, **packager** et **vérifier** les extensions backoffice inwink.
+
+Une extension inwink est une SPA React/TypeScript 100 % client-side, qui s'authentifie en OIDC (Authorization Code + PKCE) et appelle les API inwink en Bearer token. Cette CLI génère le squelette conforme (auth, config Vite, manifest, packaging) pour éviter de le réécrire à la main, puis automatise le build + zip + contrôle de conformité.
+
+S'utilise via `npx`, sans installation :
+
+```bash
+npx @inwink-mcp/backoffice-extension-helpers@latest <commande> [options]
+```
+
+## Commandes
+
+### `bootstrap`
+
+Génère le squelette d'une extension dans le dossier courant (ou `--dir`).
+
+```bash
+npx @inwink-mcp/backoffice-extension-helpers@latest bootstrap \
+  --name mon-extension \
+  --display-name "Mon Extension" \
+  --description "Ce que fait l'extension." \
+  --author moi@inwink.com \
+  --event-api-url https://.../event \
+  --community-api-url https://.../community \
+  --customer-api-url https://.../customer
+```
+
+| Option | Description |
+|--------|-------------|
+| `--name <slug>` | **(requis)** Slug unique (minuscules, chiffres, tirets) |
+| `--display-name <name>` | **(requis)** Nom affiché dans l'interface inwink |
+| `--description <text>` | **(requis)** Description courte |
+| `--author <email>` | **(requis)** Email de l'auteur |
+| `--event-api-url <url>` | **(requis)** URL de base de l'API Event |
+| `--community-api-url <url>` | **(requis)** URL de base de l'API Community |
+| `--customer-api-url <url>` | **(requis)** URL de base de l'API Customer |
+| `--template <id>` | Template à utiliser (défaut : `vite-extension`) |
+| `--dir <path>` | Dossier cible (défaut : dossier courant) |
+| `--force` | Écrire même si le dossier cible n'est pas vide |
+| `--install` | Lancer `npm install` après la génération |
+
+Fichiers générés : `extension.manifest.json`, `package.json`, `vite.config.ts`, `tsconfig*.json`, `index.html`, `src/` (auth OIDC, `api/endpoints.ts`, hooks `useInwink*Api`, `main.tsx`, `App.tsx`), `scripts/zip-build.mjs`, ainsi que `AGENTS.md` et `CLAUDE.md` pour guider les agents IA. Les URLs d'API sont injectées dans `src/api/endpoints.ts`.
+
+### `package`
+
+Build + zip `{name}-{version}.zip` + vérification de conformité, en une commande.
+
+```bash
+npx @inwink-mcp/backoffice-extension-helpers@latest package
+```
+
+| Option | Description |
+|--------|-------------|
+| `--dir <path>` | Dossier du projet (défaut : dossier courant) |
+
+Lance `npm run build` dans le projet, zippe le **contenu** de `dist/`, puis vérifie la conformité. Sort en code ≠ 0 si la conformité échoue.
+
+### `verify`
+
+Vérifie la conformité **sans** rebuild (utile en CI ou après un build manuel).
+
+```bash
+npx @inwink-mcp/backoffice-extension-helpers@latest verify
+```
+
+| Option | Description |
+|--------|-------------|
+| `--dir <path>` | Dossier du projet (défaut : dossier courant) |
+| `--zip <file>` | Chemin d'un zip à inspecter |
+
+Contrôles effectués :
+
+- `extension.manifest.json` présent, `name` (slug) et `version` (semver) valides ;
+- `dist/` contient `index.html` + `extension.manifest.json` à la racine + `assets/` ;
+- le zip contient `index.html` et `extension.manifest.json` à la racine, sans `node_modules/`, `src/` ni `dist/` ;
+- avertissements : `base: './'` absent de `vite.config.ts`, usage de `BrowserRouter`.
+
+## Templates
+
+Les templates sont des sous-dossiers de [`templates/`](templates/). Le seul template actuel est [`vite-extension`](templates/vite-extension/). En ajouter d'autres : créer un nouveau sous-dossier (les fichiers `.tpl` voient leurs placeholders `__NAME__`, `__DISPLAY_NAME__`, `__DESCRIPTION__`, `__AUTHOR__` substitués et leur suffixe `.tpl` retiré ; les autres fichiers sont copiés tels quels).
+
+## Développement
+
+```bash
+npm install
+npm run build     # compile src/ → dist/cli.js (tsup, ESM, shebang)
+npm run dev       # build en watch
+```
+
+Test local rapide :
+
+```bash
+node dist/cli.js bootstrap --name demo --display-name "Demo" --description "..." --author a@b.com --dir /tmp/demo
+```

package/dist/cli.js

@@ -0,0 +1,500 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/apply.ts
+import path3 from "path";
+import pc2 from "picocolors";
+
+// src/lib/log.ts
+import pc from "picocolors";
+function info(message) {
+  process.stdout.write(`${message}
+`);
+}
+function success(message) {
+  process.stdout.write(`${pc.green("\u2713")} ${message}
+`);
+}
+function warn(message) {
+  process.stderr.write(`${pc.yellow("\u26A0")} ${message}
+`);
+}
+function error(message) {
+  process.stderr.write(`${pc.red("\u2717")} ${message}
+`);
+}
+function printVerifyResult(result) {
+  for (const w of result.warnings) warn(w);
+  for (const e of result.errors) error(e);
+  if (result.errors.length === 0) {
+    success(
+      result.warnings.length > 0 ? `Conformit\xE9 OK (${result.warnings.length} avertissement(s)).` : "Conformit\xE9 OK."
+    );
+    return true;
+  }
+  error(`Conformit\xE9 \xC9CHOU\xC9E : ${result.errors.length} erreur(s).`);
+  return false;
+}
+
+// src/lib/manifest.ts
+import fs from "fs";
+import path from "path";
+var MANIFEST_FILENAME = "extension.manifest.json";
+var SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-.]+)?(?:\+[0-9A-Za-z-.]+)?$/;
+function isValidSlug(value) {
+  return SLUG_RE.test(value);
+}
+function isValidSemver(value) {
+  return SEMVER_RE.test(value);
+}
+function manifestPath(projectDir) {
+  return path.join(projectDir, MANIFEST_FILENAME);
+}
+function readManifest(projectDir) {
+  const file = manifestPath(projectDir);
+  if (!fs.existsSync(file)) {
+    throw new Error(`${MANIFEST_FILENAME} introuvable \xE0 la racine du projet (${projectDir}).`);
+  }
+  let raw;
+  try {
+    raw = fs.readFileSync(file, "utf8");
+  } catch (err) {
+    throw new Error(`Impossible de lire ${MANIFEST_FILENAME} : ${err.message}`);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`${MANIFEST_FILENAME} n'est pas un JSON valide : ${err.message}`);
+  }
+}
+function getNameAndVersion(manifest) {
+  const { name, version } = manifest;
+  if (typeof name !== "string" || !name.trim()) {
+    throw new Error(`${MANIFEST_FILENAME} doit d\xE9finir un "name" non vide.`);
+  }
+  if (typeof version !== "string" || !version.trim()) {
+    throw new Error(`${MANIFEST_FILENAME} doit d\xE9finir une "version" non vide.`);
+  }
+  return { name, version };
+}
+
+// src/lib/templates.ts
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+var here = path2.dirname(fileURLToPath(import.meta.url));
+var packageRoot = path2.resolve(here, "..");
+var templatesRoot = path2.join(packageRoot, "templates");
+function listTemplates() {
+  if (!fs2.existsSync(templatesRoot)) return [];
+  return fs2.readdirSync(templatesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+}
+function templateExists(id) {
+  return listTemplates().includes(id);
+}
+function escapeForJson(value) {
+  const serialized = JSON.stringify(value);
+  return serialized.slice(1, -1);
+}
+function substitute(content, ph, json) {
+  const v = (value) => json ? escapeForJson(value) : value;
+  return content.replaceAll("__NAME__", v(ph.name)).replaceAll("__DISPLAY_NAME__", v(ph.displayName)).replaceAll("__DESCRIPTION__", v(ph.description)).replaceAll("__AUTHOR__", v(ph.author)).replaceAll("__EVENT_API_URL__", v(ph.eventApiUrl)).replaceAll("__COMMUNITY_API_URL__", v(ph.communityApiUrl)).replaceAll("__CUSTOMER_API_URL__", v(ph.customerApiUrl));
+}
+function renderTemplate(templateId, destDir, ph) {
+  const srcRoot = path2.join(templatesRoot, templateId);
+  if (!fs2.existsSync(srcRoot)) {
+    throw new Error(`Template introuvable : ${templateId}`);
+  }
+  const written = [];
+  walk(srcRoot, srcRoot, destDir, ph, written);
+  return written.sort();
+}
+function walk(srcRoot, current, destRoot, ph, written) {
+  for (const entry of fs2.readdirSync(current, { withFileTypes: true })) {
+    const srcPath = path2.join(current, entry.name);
+    if (entry.isDirectory()) {
+      walk(srcRoot, srcPath, destRoot, ph, written);
+      continue;
+    }
+    const rel = path2.relative(srcRoot, srcPath);
+    const isTpl = entry.name.endsWith(".tpl");
+    const relOut = isTpl ? rel.slice(0, -".tpl".length) : rel;
+    const destPath = path2.join(destRoot, relOut);
+    fs2.mkdirSync(path2.dirname(destPath), { recursive: true });
+    if (isTpl) {
+      const content = fs2.readFileSync(srcPath, "utf8");
+      const isJson = destPath.endsWith(".json");
+      fs2.writeFileSync(destPath, substitute(content, ph, isJson));
+    } else {
+      fs2.copyFileSync(srcPath, destPath);
+    }
+    written.push(relOut.split(path2.sep).join("/"));
+  }
+}
+
+// src/commands/apply.ts
+function apply(template, opts) {
+  const projectDir = path3.resolve(opts.dir ?? process.cwd());
+  if (!templateExists(template)) {
+    error(`Template inconnu : "${template}".`);
+    info(`Templates disponibles : ${listTemplates().join(", ") || "(aucun)"}`);
+    return 1;
+  }
+  let manifest;
+  try {
+    manifest = readManifest(projectDir);
+  } catch (err) {
+    error(`Projet cible invalide : ${err.message}`);
+    return 1;
+  }
+  const str = (value) => typeof value === "string" ? value : "";
+  const placeholders = {
+    name: str(manifest.name),
+    displayName: str(manifest.displayName),
+    description: str(manifest.description),
+    author: str(manifest.author),
+    // Les URLs d'API sont déjà figées dans le projet (src/api/endpoints.ts) ;
+    // un overlay ne les ré-injecte pas.
+    eventApiUrl: "",
+    communityApiUrl: "",
+    customerApiUrl: ""
+  };
+  let written;
+  try {
+    written = renderTemplate(template, projectDir, placeholders);
+  } catch (err) {
+    error(`\xC9chec de l'application : ${err.message}`);
+    return 1;
+  }
+  success(`Template "${template}" appliqu\xE9 sur ${projectDir}`);
+  for (const file of written) {
+    info(`  ${pc2.dim("~")} ${file}`);
+  }
+  return 0;
+}
+
+// src/commands/bootstrap.ts
+import fs3 from "fs";
+import path4 from "path";
+import pc3 from "picocolors";
+
+// src/lib/run.ts
+import { spawnSync } from "child_process";
+function runNpm(args, cwd) {
+  const result = spawnSync("npm", args, {
+    cwd,
+    stdio: "inherit",
+    shell: true
+  });
+  if (result.error) {
+    throw new Error(`\xC9chec du lancement de "npm ${args.join(" ")}" : ${result.error.message}`);
+  }
+  return result.status ?? 1;
+}
+
+// src/commands/bootstrap.ts
+function validateApiUrl(flag, value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return `${flag} n'est pas une URL valide : "${value}".`;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return `${flag} doit \xEAtre une URL http(s) : "${value}".`;
+  }
+  return null;
+}
+function bootstrap(opts) {
+  const missing = [];
+  if (!opts.name) missing.push("--name");
+  if (!opts.displayName) missing.push("--display-name");
+  if (!opts.description) missing.push("--description");
+  if (!opts.author) missing.push("--author");
+  if (!opts.eventApiUrl) missing.push("--event-api-url");
+  if (!opts.communityApiUrl) missing.push("--community-api-url");
+  if (!opts.customerApiUrl) missing.push("--customer-api-url");
+  if (missing.length > 0) {
+    error(`Flags obligatoires manquants : ${missing.join(", ")}.`);
+    info('Exemple : inwink-extension bootstrap --name mon-ext --display-name "Mon Ext" --description "..." --author moi@inwink.com --event-api-url https://.../event --community-api-url https://.../community --customer-api-url https://.../customer');
+    return 1;
+  }
+  if (!isValidSlug(opts.name)) {
+    error(`--name doit \xEAtre un slug valide (minuscules, chiffres, tirets) : "${opts.name}".`);
+    return 1;
+  }
+  const urlChecks = [
+    ["--event-api-url", opts.eventApiUrl],
+    ["--community-api-url", opts.communityApiUrl],
+    ["--customer-api-url", opts.customerApiUrl]
+  ];
+  for (const [flag, value] of urlChecks) {
+    const err = validateApiUrl(flag, value);
+    if (err) {
+      error(err);
+      return 1;
+    }
+    if (value.startsWith("http://")) {
+      warn(`${flag} utilise http:// (non s\xE9curis\xE9) \u2014 privil\xE9giez https://.`);
+    }
+  }
+  if (!templateExists(opts.template)) {
+    error(`Template inconnu : "${opts.template}".`);
+    info(`Templates disponibles : ${listTemplates().join(", ") || "(aucun)"}`);
+    return 1;
+  }
+  const destDir = path4.resolve(opts.dir ?? process.cwd());
+  if (fs3.existsSync(destDir)) {
+    if (fs3.statSync(destDir).isFile()) {
+      error(`La cible existe et n'est pas un dossier : ${destDir}`);
+      return 1;
+    }
+    const entries = fs3.readdirSync(destDir);
+    if (entries.length > 0 && !opts.force) {
+      error(`Le dossier cible n'est pas vide : ${destDir}`);
+      info("Utilisez --force pour \xE9crire malgr\xE9 tout, ou --dir vers un dossier vide.");
+      return 1;
+    }
+  } else {
+    fs3.mkdirSync(destDir, { recursive: true });
+  }
+  const placeholders = {
+    name: opts.name,
+    displayName: opts.displayName,
+    description: opts.description,
+    author: opts.author,
+    eventApiUrl: opts.eventApiUrl,
+    communityApiUrl: opts.communityApiUrl,
+    customerApiUrl: opts.customerApiUrl
+  };
+  let written;
+  try {
+    written = renderTemplate(opts.template, destDir, placeholders);
+  } catch (err) {
+    error(`\xC9chec de la g\xE9n\xE9ration : ${err.message}`);
+    return 1;
+  }
+  success(`Extension "${opts.displayName}" g\xE9n\xE9r\xE9e dans ${destDir} (template: ${opts.template})`);
+  for (const file of written) {
+    info(`  ${pc3.dim("+")} ${file}`);
+  }
+  info("");
+  info(pc3.dim("API configur\xE9es (src/api/endpoints.ts) :"));
+  info(`  ${pc3.dim("event    ")} ${opts.eventApiUrl}`);
+  info(`  ${pc3.dim("community")} ${opts.communityApiUrl}`);
+  info(`  ${pc3.dim("customer ")} ${opts.customerApiUrl}`);
+  if (opts.install) {
+    info("");
+    info("Installation des d\xE9pendances (npm install)\u2026");
+    const code = runNpm(["install"], destDir);
+    if (code !== 0) {
+      warn("npm install a \xE9chou\xE9 \u2014 lancez-le manuellement.");
+      return code;
+    }
+  }
+  info("");
+  info(pc3.bold("Prochaines \xE9tapes :"));
+  if (opts.dir) info(`  cd ${opts.dir}`);
+  if (!opts.install) info("  npm install");
+  info("  npm run dev          # d\xE9veloppement local");
+  info("  npx @inwink-mcp/backoffice-extension-helpers package   # build + zip + v\xE9rification");
+  return 0;
+}
+
+// src/commands/pack.ts
+import path7 from "path";
+
+// src/lib/verify.ts
+import fs4 from "fs";
+import path5 from "path";
+import AdmZip from "adm-zip";
+function verifyExtension(options) {
+  const { projectDir, requireDist = false } = options;
+  const errors = [];
+  const warnings = [];
+  let name;
+  let version;
+  try {
+    const manifest = readManifest(projectDir);
+    const nv = getNameAndVersion(manifest);
+    name = nv.name;
+    version = nv.version;
+    if (!isValidSlug(name)) {
+      errors.push(`Le "name" du manifest n'est pas un slug valide (minuscules + tirets) : "${name}".`);
+    }
+    if (!isValidSemver(version)) {
+      errors.push(`La "version" du manifest n'est pas un semver valide : "${version}".`);
+    }
+  } catch (err) {
+    errors.push(err.message);
+  }
+  const distDir = path5.join(projectDir, "dist");
+  if (!fs4.existsSync(distDir)) {
+    if (requireDist) {
+      errors.push("Dossier dist/ introuvable apr\xE8s le build.");
+    }
+  } else {
+    if (!fs4.existsSync(path5.join(distDir, "index.html"))) {
+      errors.push("dist/index.html manquant.");
+    }
+    if (!fs4.existsSync(path5.join(distDir, "extension.manifest.json"))) {
+      errors.push("dist/extension.manifest.json manquant (le plugin Vite doit le copier).");
+    }
+    const assetsDir = path5.join(distDir, "assets");
+    if (!fs4.existsSync(assetsDir) || !fs4.statSync(assetsDir).isDirectory()) {
+      warnings.push("dist/assets/ introuvable \u2014 build Vite incomplet ?");
+    }
+  }
+  const zipPath = resolveZipPath(options, projectDir, name, version);
+  if (zipPath && fs4.existsSync(zipPath)) {
+    verifyZip(zipPath, errors);
+  } else if (options.zipPath) {
+    errors.push(`Zip introuvable : ${options.zipPath}`);
+  }
+  checkViteBase(projectDir, warnings);
+  checkRouter(projectDir, warnings);
+  return { errors, warnings };
+}
+function resolveZipPath(options, projectDir, name, version) {
+  if (options.zipPath) {
+    return path5.isAbsolute(options.zipPath) ? options.zipPath : path5.join(projectDir, options.zipPath);
+  }
+  if (name && version) {
+    const candidate = path5.join(projectDir, `${name}-${version}.zip`);
+    return fs4.existsSync(candidate) ? candidate : void 0;
+  }
+  return void 0;
+}
+function verifyZip(zipPath, errors) {
+  let entries;
+  try {
+    entries = new AdmZip(zipPath).getEntries();
+  } catch (err) {
+    errors.push(`Impossible de lire le zip ${path5.basename(zipPath)} : ${err.message}`);
+    return;
+  }
+  const names = entries.map((e) => e.entryName.split("\\").join("/"));
+  if (!names.includes("index.html")) {
+    errors.push("Le zip ne contient pas index.html \xE0 la racine.");
+  }
+  if (!names.includes("extension.manifest.json")) {
+    errors.push("Le zip ne contient pas extension.manifest.json \xE0 la racine.");
+  }
+  if (names.some((n) => n.startsWith("node_modules/"))) {
+    errors.push("Le zip contient un dossier node_modules/ (interdit).");
+  }
+  if (names.some((n) => n.startsWith("src/"))) {
+    errors.push("Le zip contient un dossier src/ (le code source ne doit pas \xEAtre packag\xE9).");
+  }
+  if (names.some((n) => n.startsWith("dist/"))) {
+    errors.push("Le zip contient un dossier dist/ : zippez le CONTENU de dist/, pas le dossier.");
+  }
+}
+function checkViteBase(projectDir, warnings) {
+  const file = path5.join(projectDir, "vite.config.ts");
+  if (!fs4.existsSync(file)) return;
+  const content = fs4.readFileSync(file, "utf8");
+  if (!/base:\s*['"]\.\/['"]/.test(content)) {
+    warnings.push("vite.config.ts : `base: './'` introuvable \u2014 les assets risquent de casser apr\xE8s d\xE9ploiement.");
+  }
+}
+function checkRouter(projectDir, warnings) {
+  const srcDir = path5.join(projectDir, "src");
+  if (!fs4.existsSync(srcDir)) return;
+  if (sourceUsesBrowserRouter(srcDir)) {
+    warnings.push("Usage de BrowserRouter d\xE9tect\xE9 \u2014 utilisez HashRouter pour l'h\xE9bergement versionn\xE9.");
+  }
+}
+function sourceUsesBrowserRouter(dir) {
+  for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
+    const full = path5.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (sourceUsesBrowserRouter(full)) return true;
+    } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
+      if (/\bBrowserRouter\b/.test(fs4.readFileSync(full, "utf8"))) return true;
+    }
+  }
+  return false;
+}
+
+// src/lib/zip.ts
+import fs5 from "fs";
+import path6 from "path";
+import AdmZip2 from "adm-zip";
+function zipDist(projectDir, name, version) {
+  const distDir = path6.join(projectDir, "dist");
+  if (!fs5.existsSync(distDir)) {
+    throw new Error("Dossier dist/ introuvable. Lancez le build avant de zipper.");
+  }
+  const zipFileName = `${name}-${version}.zip`;
+  const zipFilePath = path6.join(projectDir, zipFileName);
+  const zip = new AdmZip2();
+  zip.addLocalFolder(distDir);
+  zip.writeZip(zipFilePath);
+  return zipFilePath;
+}
+
+// src/commands/pack.ts
+function pack(opts) {
+  const projectDir = path7.resolve(opts.dir ?? process.cwd());
+  let name;
+  let version;
+  try {
+    ({ name, version } = getNameAndVersion(readManifest(projectDir)));
+  } catch (err) {
+    error(err.message);
+    return 1;
+  }
+  info("Build (npm run build)\u2026");
+  const buildCode = runNpm(["run", "build"], projectDir);
+  if (buildCode !== 0) {
+    error("Le build a \xE9chou\xE9 \u2014 corrigez les erreurs ci-dessus.");
+    return buildCode;
+  }
+  let zipPath;
+  try {
+    zipPath = zipDist(projectDir, name, version);
+  } catch (err) {
+    error(err.message);
+    return 1;
+  }
+  success(`Zip cr\xE9\xE9 : ${path7.basename(zipPath)}`);
+  info("V\xE9rification de conformit\xE9\u2026");
+  const result = verifyExtension({ projectDir, zipPath, requireDist: true });
+  const ok = printVerifyResult(result);
+  return ok ? 0 : 1;
+}
+
+// src/commands/verify.ts
+import path8 from "path";
+function verify(opts) {
+  const projectDir = path8.resolve(opts.dir ?? process.cwd());
+  info("V\xE9rification de conformit\xE9\u2026");
+  const result = verifyExtension({ projectDir, zipPath: opts.zip });
+  const ok = printVerifyResult(result);
+  return ok ? 0 : 1;
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("inwink-extension").description("CLI pour bootstrapper, packager et v\xE9rifier les extensions backoffice inwink.").showHelpAfterError();
+program.command("bootstrap").description("G\xE9n\xE8re le squelette d'une extension inwink.").requiredOption("--name <slug>", "slug unique de l'extension (minuscules, tirets)").requiredOption("--display-name <name>", "nom affich\xE9 dans l'interface inwink").requiredOption("--description <text>", "description courte de l'extension").requiredOption("--author <email>", "email de l'auteur").requiredOption("--event-api-url <url>", "URL de base de l'API Event inwink").requiredOption("--community-api-url <url>", "URL de base de l'API Community inwink").requiredOption("--customer-api-url <url>", "URL de base de l'API Customer inwink").option("--template <id>", "template \xE0 utiliser", "vite-extension").option("--dir <path>", "dossier cible (d\xE9faut : dossier courant)").option("--force", "\xE9crire m\xEAme si le dossier cible n'est pas vide", false).option("--install", "lancer npm install apr\xE8s la g\xE9n\xE9ration", false).action((options) => {
+  process.exitCode = bootstrap(options);
+});
+program.command("apply").description("Applique un template par-dessus un projet existant (overlay).").argument("<template>", "template \xE0 appliquer (sous-dossier de templates/)").option("--dir <path>", "dossier du projet (d\xE9faut : dossier courant)").action((template, options) => {
+  process.exitCode = apply(template, options);
+});
+program.command("package").description("Build + zip + v\xE9rification de conformit\xE9 de l'extension.").option("--dir <path>", "dossier du projet (d\xE9faut : dossier courant)").action((options) => {
+  process.exitCode = pack(options);
+});
+program.command("verify").description("V\xE9rifie la conformit\xE9 de l'extension (sans build).").option("--dir <path>", "dossier du projet (d\xE9faut : dossier courant)").option("--zip <file>", "chemin d'un zip \xE0 inspecter").action((options) => {
+  process.exitCode = verify(options);
+});
+program.parseAsync(process.argv).catch((err) => {
+  process.stderr.write(`${err.message}
+`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@inwink-mcp/backoffice-extension-helpers",
+  "version": "1.0.0",
+  "author": "inwink",
+  "license": "ISC",
+  "description": "CLI pour bootstrapper, packager et vérifier les extensions backoffice inwink.",
+  "type": "module",
+  "bin": {
+    "inwink-extension": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "prepublishOnly": "npm run build",
+    "test": "npm run build && node scripts/test.mjs",
+    "test-verify": "node dist/cli.js verify --dir .test-app"
+  },
+  "dependencies": {
+    "adm-zip": "^0.5.16",
+    "commander": "^13.0.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/adm-zip": "^0.5.7",
+    "@types/node": "^22.14.1",
+    "tsup": "^8.3.5",
+    "typescript": "^5.8.3"
+  }
+}

package/templates/test-app/src/pages/HomePage.tsx.tpl

@@ -0,0 +1,55 @@
+import { useState } from 'react';
+import { FiLogIn, FiLogOut, FiRefreshCw } from 'react-icons/fi';
+import { useAuth } from '../hooks/useAuth';
+import { useInwinkEventApi } from '../hooks/useInwinkEventApi';
+
+// Version de HomePage générée par le template overlay "test-app".
+// Sert à vérifier que le squelette bootstrappé compile et que les hooks API
+// (ici useInwinkEventApi) sont utilisables.
+export default function HomePage() {
+  const { isAuthenticated, isLoading, login, logout, user } = useAuth();
+  const eventApi = useInwinkEventApi();
+  const [result, setResult] = useState<string>('');
+  const [error, setError] = useState<string>('');
+
+  async function callEventApi() {
+    setError('');
+    setResult('');
+    try {
+      const data = await eventApi.post('/dae274d9-e86e-f011-8dca-0022488a3cad/session/query', {
+        "selects": { "id": true, "title": true, "status": true, "moderators": { "person": { "id": true, "firstname": true, "lastname": true, "company": true, "mail": true } }, "startDate": true, "endDate": true, "room": { "name": true, "id": true }, "speakers": { "id": true, "firstname": true, "lastname": true, "company": true, "mail": true }, "exhibitors": { "id": true, "name": true }, "infos": { "registered": true, "attended": true, "attendedOnsite": true, "attendedOnlineLive": true, "attendedOnlineReplay": true } },
+        "orders": [{ "desc": true, "value": { "validFrom": {} } }],
+        "page": { "index": 0, "size": 200 }
+      });
+      setResult(JSON.stringify(data, null, 2));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    }
+  }
+
+  return (
+    <main>
+      <h1>__DISPLAY_NAME__ — test API Event</h1>
+      {!isAuthenticated ? (
+        <button disabled={isLoading} onClick={() => void login()}>
+          <FiLogIn aria-hidden />
+          {isLoading ? 'Initialisation...' : 'Se connecter'}
+        </button>
+      ) : (
+        <>
+          <p>Connecté en tant que : {user?.profile.email ?? 'Inconnu'}</p>
+          <button onClick={() => void callEventApi()}>
+            <FiRefreshCw aria-hidden />
+            Appeler l'API Event
+          </button>
+          <button onClick={() => void logout()}>
+            <FiLogOut aria-hidden />
+            Se déconnecter
+          </button>
+          {result && <pre>{result}</pre>}
+          {error && <p role="alert">Erreur : {error}</p>}
+        </>
+      )}
+    </main>
+  );
+}