@lastbrain/app 2.0.1 → 2.0.3

package/dist/src/scripts/module-build.js

@@ -0,0 +1,1280 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+// Utiliser PROJECT_ROOT si défini (pour pnpm --filter), sinon process.cwd()
+const projectRoot = process.env.PROJECT_ROOT || process.cwd();
+// Si on est dans une app, monter jusqu'à la racine du monorepo
+const _monorepoRoot = projectRoot.includes("/apps/")
+    ? path.resolve(projectRoot, "..", "..")
+    : projectRoot;
+const appDirectory = path.join(projectRoot, "app");
+// Mode debug activé via --debug
+const isDebugMode = process.argv.includes("--debug");
+// Créer un require dans le contexte de l'application pour résoudre les modules installés dans l'app
+const projectRequire = createRequire(path.join(projectRoot, "package.json"));
+// Charger les modules depuis modules.json
+async function loadModuleConfigs() {
+    const moduleConfigs = [];
+    const modulesJsonPath = path.join(projectRoot, ".lastbrain", "modules.json");
+    if (!fs.existsSync(modulesJsonPath)) {
+        return moduleConfigs;
+    }
+    try {
+        const modulesData = JSON.parse(fs.readFileSync(modulesJsonPath, "utf-8"));
+        const modules = modulesData.modules || [];
+        for (const module of modules) {
+            // Ne charger que les modules actifs
+            if (module.active === false) {
+                continue;
+            }
+            const packageName = module.package;
+            try {
+                // Extraire le suffix du module (la partie après @lastbrain/module- ou @lastbrain-labs/module-)
+                const moduleSuffix = packageName
+                    .replace("@lastbrain/module-", "")
+                    .replace("@lastbrain-labs/module-", "");
+                const possibleConfigNames = [
+                    `${moduleSuffix}.build.config`,
+                    "build.config",
+                ];
+                let loaded = false;
+                for (const configName of possibleConfigNames) {
+                    try {
+                        // Résoudre le chemin du module depuis l'application
+                        const modulePath = projectRequire.resolve(`${packageName}/${configName}`);
+                        // Convertir en URL file:// pour l'import dynamique
+                        const moduleUrl = `file://${modulePath}`;
+                        const moduleImport = await import(moduleUrl);
+                        if (moduleImport.default) {
+                            moduleConfigs.push(moduleImport.default);
+                            loaded = true;
+                            break;
+                        }
+                    }
+                    catch {
+                        // Essayer le nom suivant
+                    }
+                }
+                if (!loaded) {
+                    console.warn(`⚠️  Could not load build config for ${packageName}`);
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️  Failed to load module ${packageName}:`, error);
+            }
+        }
+    }
+    catch (error) {
+        console.error("❌ Error loading modules.json:", error);
+    }
+    return moduleConfigs;
+}
+const sectionDirectoryMap = {
+    public: ["(public)"],
+    auth: ["auth"],
+    admin: ["admin"],
+    user: ["auth", "user"],
+};
+const sectionLayoutMap = {
+    auth: "AuthLayout",
+    admin: "AdminLayout",
+    "(public)": "PublicLayout",
+};
+const generatedSections = new Set();
+const navigation = {
+    public: [],
+    auth: [],
+    admin: [],
+};
+const userMenu = [];
+function ensureDirectory(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+function ensureSectionLayout(sectionPath) {
+    const sectionDir = path.join(appDirectory, ...sectionPath);
+    const sectionKey = sectionPath[0];
+    // Éviter de générer plusieurs fois le même layout
+    if (generatedSections.has(sectionKey)) {
+        return;
+    }
+    ensureDirectory(sectionDir);
+    const layoutName = sectionLayoutMap[sectionKey];
+    if (layoutName) {
+        const layoutPath = path.join(sectionDir, "layout.tsx");
+        if (!fs.existsSync(layoutPath)) {
+            const layoutContent = `import { ${layoutName} } from "@lastbrain/app";
+
+export default function SectionLayout({ children }: { children: React.ReactNode }) {
+  return <${layoutName}>{children}</${layoutName}>;
+}
+`;
+            fs.writeFileSync(layoutPath, layoutContent);
+            console.log(`📐 Generated section layout: ${layoutPath}`);
+        }
+    }
+    generatedSections.add(sectionKey);
+}
+function toPascalCase(value) {
+    return value
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map((segment) => segment[0].toUpperCase() + segment.slice(1))
+        .join("");
+}
+function buildPage(moduleConfig, page) {
+    // Extraire le préfixe du module (ex: @lastbrain/module-auth -> auth, @lastbrain-labs/module-recipes-pro -> recipes)
+    // Enlever -pro pour les routes auth et admin afin d'avoir des chemins propres
+    const modulePrefix = moduleConfig.moduleName
+        .replace(/^@lastbrain\/module-/, "")
+        .replace(/^@lastbrain-labs\/module-/, "")
+        .replace(/-pro$/, "") // Enlever le suffixe -pro
+        .toLowerCase();
+    if (isDebugMode) {
+        console.log(`🔄 Building page for module ${modulePrefix}: ${page.path}`);
+    }
+    // Ajouter le préfixe du module au path pour les sections admin et auth,
+    // MAIS seulement quand la section ne correspond PAS au module lui-même
+    let effectivePath = page.path;
+    if (page.section === "admin" ||
+        (page.section === "auth" && modulePrefix !== "auth")) {
+        // Éviter les doublons si le préfixe est déjà présent
+        if (!page.path.startsWith(`/${modulePrefix}/`)) {
+            effectivePath = `/${modulePrefix}${page.path}`;
+            if (isDebugMode) {
+                console.log(`📂 Added module prefix: ${page.path} -> ${effectivePath}`);
+            }
+        }
+        else if (isDebugMode) {
+            console.log(`✅ Module prefix already present: ${page.path}`);
+        }
+    }
+    else if (page.section === "auth" &&
+        modulePrefix === "auth" &&
+        isDebugMode) {
+        console.log(`🏠 Auth module in auth section, no prefix needed: ${page.path}`);
+    }
+    const segments = effectivePath.replace(/^\/+/, "").split("/").filter(Boolean);
+    const sectionPath = sectionDirectoryMap[page.section] ?? ["(public)"];
+    // Générer le layout de section si nécessaire
+    ensureSectionLayout(sectionPath);
+    const routeDir = path.join(appDirectory, ...sectionPath, ...segments);
+    const filePath = path.join(routeDir, "page.tsx");
+    ensureDirectory(routeDir);
+    const wrapperSuffix = segments.length
+        ? toPascalCase(segments.join("-"))
+        : "Root";
+    const wrapperName = `${page.componentExport}${wrapperSuffix}Route`;
+    // Vérifier si la route a des paramètres dynamiques (segments avec [])
+    const hasDynamicParams = segments.some((seg) => seg.startsWith("[") && seg.endsWith("]"));
+    // Pour les pages publiques (signin, signup, etc.), utiliser dynamic import sans SSR
+    // pour éviter les erreurs d'hydratation avec les IDs HeroUI/React Aria
+    const isPublicAuthPage = page.section === "public" &&
+        (page.path.includes("signin") ||
+            page.path.includes("signup") ||
+            page.path.includes("reset-password"));
+    // Détecter si c'est la page de détail utilisateur qui a besoin des user tabs
+    const isUserDetailPage = page.section === "admin" &&
+        page.path.includes("users/[id]") &&
+        page.componentExport === "UserPage";
+    // Détecter les pages légales qui utilisent cookies (privacy, terms, returns)
+    const isLegalPage = page.section === "public" &&
+        (page.path.includes("privacy") ||
+            page.path.includes("terms") ||
+            page.path.includes("returns"));
+    let content;
+    if (isUserDetailPage) {
+        // Page spéciale SSR avec injection des user tabs
+        // On importe directement depuis app/config au lieu de passer via props
+        content = `// GENERATED BY LASTBRAIN MODULE BUILD
+import { UserDetailPage } from "${moduleConfig.moduleName}";
+
+interface UserPageProps { params: Promise<{ id: string }> }
+
+async function getModuleUserTabs() {
+  try {
+    // Depuis /app/admin/auth/users/[id]/ vers /apps/test-01/config/user-tabs
+    const { moduleUserTabs } = await import("../../../../../config/user-tabs");
+    return moduleUserTabs || [];
+  } catch (e) {
+    console.warn("[user-detail-wrapper] erreur chargement user-tabs", e);
+    return [];
+  }
+}
+
+export default async function ${wrapperName}(props: UserPageProps) {
+  const { id } = await props.params;
+  const moduleUserTabs = await getModuleUserTabs();
+  return <UserDetailPage userId={id} moduleUserTabs={moduleUserTabs} />;
+}
+`;
+    }
+    else if (isPublicAuthPage) {
+        content = `// GENERATED BY LASTBRAIN MODULE BUILD
+"use client";
+
+import dynamic from "next/dynamic";
+
+const ${page.componentExport} = dynamic(
+  () => import("${moduleConfig.moduleName}").then((mod) => ({ default: mod.${page.componentExport} })),
+  { ssr: false }
+);
+
+export default function ${wrapperName}${hasDynamicParams ? "(props: Record<string, unknown>)" : "()"} {
+  return <${page.componentExport} ${hasDynamicParams ? "{...props}" : ""} />;
+}
+`;
+    }
+    else if (isLegalPage) {
+        content = `// GENERATED BY LASTBRAIN MODULE BUILD
+import { ${page.componentExport} } from "${moduleConfig.moduleName}";
+
+export const dynamic = 'force-dynamic';
+
+export default function ${wrapperName}${hasDynamicParams ? "(props: Record<string, unknown>)" : "()"} {
+  return <${page.componentExport} ${hasDynamicParams ? "{...props}" : ""} />;
+}
+`;
+    }
+    else {
+        content = `// GENERATED BY LASTBRAIN MODULE BUILD
+import { ${page.componentExport} } from "${moduleConfig.moduleName}";
+
+export default function ${wrapperName}${hasDynamicParams ? "(props: Record<string, unknown>)" : "()"} {
+  return <${page.componentExport} ${hasDynamicParams ? "{...props}" : ""} />;
+}
+`;
+    }
+    fs.writeFileSync(filePath, content);
+    if (isDebugMode) {
+        console.log(`⭐ Generated page: ${filePath}`);
+    }
+    const entry = {
+        label: `Module:${moduleConfig.moduleName} ${page.componentExport}`,
+        path: effectivePath,
+        module: moduleConfig.moduleName,
+        section: page.section,
+    };
+    if (page.section === "user") {
+        userMenu.push(entry);
+    }
+    else if (page.section) {
+        navigation[page.section]?.push(entry);
+    }
+}
+function dumpNavigation() {
+    const navPath = path.join(appDirectory, "navigation.generated.ts");
+    const content = `export type MenuEntry = { label: string; path: string; module: string; section: string };
+
+export const navigation = ${JSON.stringify(navigation, null, 2)};
+
+export const userMenu = ${JSON.stringify(userMenu, null, 2)};
+`;
+    fs.writeFileSync(navPath, content);
+    if (isDebugMode) {
+        console.log(`🧭 Generated navigation metadata: ${navPath}`);
+    }
+}
+/**
+ * Génère le fichier config/menu.ts à partir des configurations de menu des modules
+ */
+function generateMenuConfig(moduleConfigs) {
+    const configDir = path.join(projectRoot, "config");
+    ensureDirectory(configDir);
+    const menuPath = path.join(configDir, "menu.ts");
+    // Collecter les menus de tous les modules avec leurs modules sources
+    const publicMenus = [];
+    const authMenus = [];
+    const adminMenus = [];
+    const accountMenus = [];
+    moduleConfigs.forEach((moduleConfig) => {
+        if (moduleConfig.menu) {
+            if (moduleConfig.menu.public) {
+                publicMenus.push(...moduleConfig.menu.public.map((item) => ({
+                    ...item,
+                    moduleName: moduleConfig.moduleName,
+                })));
+            }
+            if (moduleConfig.menu.auth) {
+                authMenus.push(...moduleConfig.menu.auth.map((item) => ({
+                    ...item,
+                    moduleName: moduleConfig.moduleName,
+                })));
+            }
+            if (moduleConfig.menu.admin) {
+                adminMenus.push(...moduleConfig.menu.admin.map((item) => ({
+                    ...item,
+                    moduleName: moduleConfig.moduleName,
+                })));
+            }
+            if (moduleConfig.menu.account) {
+                accountMenus.push(...moduleConfig.menu.account.map((item) => ({
+                    ...item,
+                    moduleName: moduleConfig.moduleName,
+                })));
+            }
+        }
+    });
+    // Trier par ordre
+    const sortByOrder = (a, b) => {
+        return (a.order ?? 999) - (b.order ?? 999);
+    };
+    publicMenus.sort(sortByOrder);
+    authMenus.sort(sortByOrder);
+    adminMenus.sort(sortByOrder);
+    accountMenus.sort(sortByOrder);
+    // Collecter les composants à importer dynamiquement
+    const componentImports = [];
+    const allMenus = [
+        ...publicMenus,
+        ...authMenus,
+        ...adminMenus,
+        ...accountMenus,
+    ];
+    allMenus.forEach((menu, index) => {
+        if (menu.componentExport && menu.moduleName) {
+            const componentName = `MenuComponent${index}`;
+            componentImports.push(`const ${componentName} = dynamic(() => import("${menu.moduleName}").then(mod => ({ default: mod.${menu.componentExport} })), { ssr: false });`);
+            // Ajouter une référence au composant
+            menu.__componentRef = componentName;
+        }
+    });
+    // Fonction pour préparer les menus avec les composants
+    const prepareMenusForExport = (menus) => {
+        return menus.map((menu) => {
+            const { moduleName, __componentRef, ...cleanMenu } = menu;
+            if (__componentRef) {
+                // Retourner une référence au composant au lieu de la sérialiser
+                return `{ ...${JSON.stringify(cleanMenu)}, component: ${__componentRef} }`;
+            }
+            return JSON.stringify(cleanMenu);
+        });
+    };
+    const publicMenusExport = prepareMenusForExport(publicMenus);
+    const authMenusExport = prepareMenusForExport(authMenus);
+    const adminMenusExport = prepareMenusForExport(adminMenus);
+    const accountMenusExport = prepareMenusForExport(accountMenus);
+    // Générer le contenu du fichier
+    const content = `// Auto-generated menu configuration
+// Generated from module build configs
+"use client";
+
+import dynamic from "next/dynamic";
+
+${componentImports.join("\n")}
+
+export interface MenuItem {
+  title: string;
+  description?: string;
+  icon?: string;
+  path: string;
+  order?: number;
+  shortcut?: string;
+  shortcutDisplay?: string;
+  type?: 'text' | 'icon' | 'textIcon';
+  position?: 'center' | 'end';
+  component?: React.ComponentType<any>;
+  componentExport?: string;
+  entryPoint?: string;
+}
+
+export interface MenuConfig {
+  public: MenuItem[];
+  auth: MenuItem[];
+  admin: MenuItem[];
+  account: MenuItem[];
+}
+
+export const menuConfig: MenuConfig = {
+  public: [${publicMenusExport.join(",\n    ")}],
+  auth: [${authMenusExport.join(",\n    ")}],
+  admin: [${adminMenusExport.join(",\n    ")}],
+  account: [${accountMenusExport.join(",\n    ")}],
+};
+`;
+    fs.writeFileSync(menuPath, content);
+    if (isDebugMode) {
+        console.log(`🍔 Generated menu configuration: ${menuPath}`);
+    }
+}
+function copyModuleMigrations(moduleConfigs) {
+    const supabaseMigrationsDir = path.join(projectRoot, "supabase", "migrations");
+    // S'assurer que le dossier migrations existe
+    if (!fs.existsSync(supabaseMigrationsDir)) {
+        ensureDirectory(supabaseMigrationsDir);
+    }
+    const modulesJsonPath = path.join(projectRoot, ".lastbrain", "modules.json");
+    // Charger modules.json
+    let modulesConfig = { modules: [] };
+    if (fs.existsSync(modulesJsonPath)) {
+        modulesConfig = JSON.parse(fs.readFileSync(modulesJsonPath, "utf-8"));
+    }
+    moduleConfigs.forEach((moduleConfig) => {
+        try {
+            const moduleName = moduleConfig.moduleName;
+            const copiedMigrations = [];
+            // Essayer plusieurs chemins possibles pour trouver le module
+            const possiblePaths = [
+                // Dans node_modules local de l'app
+                path.join(projectRoot, "node_modules", moduleName),
+                // Dans node_modules à la racine du workspace
+                path.join(projectRoot, "..", "..", "node_modules", moduleName),
+                // Directement dans packages/ (pour monorepo)
+                path.join(projectRoot, "..", "..", "packages", moduleName.replace("@lastbrain/", "")),
+            ];
+            let moduleBasePath = null;
+            for (const possiblePath of possiblePaths) {
+                if (fs.existsSync(possiblePath)) {
+                    moduleBasePath = possiblePath;
+                    break;
+                }
+            }
+            if (!moduleBasePath) {
+                return;
+            }
+            const moduleMigrationsDir = path.join(moduleBasePath, "supabase", "migrations");
+            if (fs.existsSync(moduleMigrationsDir)) {
+                const migrationFiles = fs.readdirSync(moduleMigrationsDir);
+                migrationFiles.forEach((file) => {
+                    if (file.endsWith(".sql")) {
+                        const sourcePath = path.join(moduleMigrationsDir, file);
+                        const destPath = path.join(supabaseMigrationsDir, file);
+                        // Copier seulement si le fichier n'existe pas déjà
+                        if (!fs.existsSync(destPath)) {
+                            fs.copyFileSync(sourcePath, destPath);
+                            console.log(`📦 Copied migration: ${file} from ${moduleName}`);
+                        }
+                        copiedMigrations.push(file);
+                    }
+                });
+            }
+            // Mettre à jour modules.json avec les migrations
+            if (copiedMigrations.length > 0) {
+                const moduleIndex = modulesConfig.modules.findIndex((m) => m.package === moduleName);
+                if (moduleIndex >= 0) {
+                    modulesConfig.modules[moduleIndex].migrations = copiedMigrations;
+                }
+                else {
+                    modulesConfig.modules.push({
+                        package: moduleName,
+                        migrations: copiedMigrations,
+                    });
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`⚠️  Could not copy migrations from ${moduleConfig.moduleName}:`, error);
+        }
+    });
+    // Sauvegarder modules.json avec les migrations mises à jour
+    ensureDirectory(path.dirname(modulesJsonPath));
+    fs.writeFileSync(modulesJsonPath, JSON.stringify(modulesConfig, null, 2));
+}
+function generateDocsPage(moduleConfigs) {
+    const docsDir = path.join(appDirectory, "docs");
+    ensureDirectory(docsDir);
+    const docsPagePath = path.join(docsDir, "page.tsx");
+    // Charger tous les modules depuis modules.json (actifs ET inactifs)
+    const modulesJsonPath = path.join(projectRoot, ".lastbrain", "modules.json");
+    let allModules = [];
+    if (fs.existsSync(modulesJsonPath)) {
+        try {
+            const modulesData = JSON.parse(fs.readFileSync(modulesJsonPath, "utf-8"));
+            allModules = modulesData.modules || [];
+        }
+        catch (error) {
+            console.error("❌ Error reading modules.json:", error);
+        }
+    }
+    // Générer les imports des composants Doc de chaque module
+    const docImports = [];
+    const moduleConfigurations = [];
+    allModules.forEach((moduleEntry) => {
+        const moduleName = moduleEntry.package;
+        // Extraire le nom du module sans le scope et sans "module-"
+        // Ex: @lastbrain/module-auth -> auth
+        // Ex: @lastbrain-labs/module-recipes-pro -> recipes
+        const moduleId = moduleName
+            .replace("@lastbrain-labs/module-", "")
+            .replace("@lastbrain/module-", "")
+            .replace(/-pro$/, ""); // Retirer le suffix -pro pour avoir le nom de base
+        const docComponentName = `${toPascalCase(moduleId)}ModuleDoc`;
+        // Trouver la config du module pour obtenir la description
+        const moduleConfig = moduleConfigs.find((mc) => mc.moduleName === moduleName);
+        const description = moduleConfig
+            ? getModuleDescription(moduleConfig)
+            : "Module non configuré";
+        // Importer le composant Doc seulement pour les modules actifs
+        if (moduleEntry.active) {
+            docImports.push(`import { ${docComponentName} } from "${moduleName}";`);
+        }
+        const config = {
+            id: moduleName, // Utiliser le nom complet du package comme ID
+            name: `Module ${toPascalCase(moduleId)}`,
+            description: description,
+            component: docComponentName,
+            active: moduleEntry.active,
+        };
+        moduleConfigurations.push(`  {
+    id: "${config.id}",
+    name: "${config.name}",
+    description: "${config.description}",
+    ${config.active ? `content: <${config.component} />,` : "content: null,"}
+    available: ${config.active},
+  }`);
+    });
+    const docsContent = `// Auto-generated docs page with module documentation
+import React from "react";
+import { DocPage } from "@lastbrain/app";
+${docImports.join("\n")}
+
+export default function DocsPage() {
+  const modules = [
+${moduleConfigurations.join(",\n")}
+  ];
+  
+  return <DocPage modules={modules} />;
+}
+`;
+    fs.writeFileSync(docsPagePath, docsContent);
+    if (isDebugMode) {
+        console.log(`📚 Generated docs page: ${docsPagePath}`);
+    }
+}
+function buildGroupedApi(apis, routePath) {
+    const segments = routePath.replace(/^\/+/, "").split("/").filter(Boolean);
+    const sanitizedSegments = segments[0] === "api" ? segments.slice(1) : segments;
+    const routeDir = path.join(appDirectory, "api", ...sanitizedSegments);
+    const filePath = path.join(routeDir, "route.ts");
+    ensureDirectory(routeDir);
+    // Grouper par module/entryPoint pour créer les exports
+    const exportsBySource = new Map();
+    apis.forEach(({ moduleConfig, api }) => {
+        const handler = `${moduleConfig.moduleName}/${api.entryPoint}`;
+        if (!exportsBySource.has(handler)) {
+            exportsBySource.set(handler, []);
+        }
+        exportsBySource.get(handler).push(api.handlerExport);
+    });
+    // Générer les exports - un export statement par source
+    const exportStatements = [];
+    exportsBySource.forEach((exports, source) => {
+        exportStatements.push(`export { ${exports.join(", ")} } from "${source}";`);
+    });
+    const content = exportStatements.join("\n") + "\n";
+    // Ajouter le marqueur de génération au début
+    const contentWithMarker = `// GENERATED BY LASTBRAIN MODULE BUILD
+${content}`;
+    fs.writeFileSync(filePath, contentWithMarker);
+    if (isDebugMode) {
+        console.log(`🔌 Generated API route: ${filePath}`);
+    }
+}
+function getModuleDescription(moduleConfig) {
+    // Essayer de déduire la description depuis les pages ou retourner une description par défaut
+    if (moduleConfig.pages.length > 0) {
+        return `${moduleConfig.pages.length} page(s), ${moduleConfig.apis.length} API(s)`;
+    }
+    return "Module documentation";
+}
+function cleanGeneratedFiles() {
+    const generatedComment = "// GENERATED BY LASTBRAIN MODULE BUILD";
+    // Fichiers de base à préserver (paths relatifs exacts)
+    const protectedFiles = new Set([
+        // API de base
+        "api/storage",
+        // Layouts de base
+        "layout.tsx",
+        "not-found.tsx",
+        "page.tsx", // Page racine seulement
+        "admin/page.tsx", // Page admin racine
+        "admin/layout.tsx", // Layout admin racine
+        "docs/page.tsx", // Page docs générée
+        // Middleware et autres fichiers core
+        "middleware.ts",
+        // Dossiers de lib et config
+        "lib",
+        "config",
+    ]);
+    // Fonction pour vérifier si un chemin est protégé
+    const isProtected = (filePath) => {
+        const relativePath = path.relative(appDirectory, filePath);
+        // Protection exacte pour certains fichiers
+        if (protectedFiles.has(relativePath)) {
+            return true;
+        }
+        // Protection par préfixe pour les dossiers
+        return Array.from(protectedFiles).some((protectedPath) => (protectedPath.endsWith("/") ||
+            ["lib", "config", "api/storage"].includes(protectedPath)) &&
+            relativePath.startsWith(protectedPath));
+    };
+    // Fonction pour nettoyer récursivement un dossier
+    const cleanDirectory = (dirPath) => {
+        if (!fs.existsSync(dirPath))
+            return;
+        const items = fs.readdirSync(dirPath);
+        for (const item of items) {
+            const itemPath = path.join(dirPath, item);
+            const stat = fs.statSync(itemPath);
+            if (stat.isDirectory()) {
+                // Nettoyer récursivement le sous-dossier
+                cleanDirectory(itemPath);
+                // Supprimer le dossier s'il est vide et non protégé
+                try {
+                    if (!isProtected(itemPath) && fs.readdirSync(itemPath).length === 0) {
+                        fs.rmdirSync(itemPath);
+                        if (isDebugMode) {
+                            console.log(`📁 Removed empty directory: ${itemPath}`);
+                        }
+                    }
+                }
+                catch {
+                    // Ignorer les erreurs de suppression de fichiers
+                }
+            }
+            else if (item.endsWith(".tsx") || item.endsWith(".ts")) {
+                // Vérifier si c'est un fichier généré
+                if (!isProtected(itemPath)) {
+                    try {
+                        const content = fs.readFileSync(itemPath, "utf-8");
+                        // Supprimer les fichiers générés ou les wrapper simples de modules
+                        if (content.includes(generatedComment) ||
+                            content.includes('from "@lastbrain/module-') ||
+                            (content.includes("export {") &&
+                                content.includes('} from "@lastbrain/module-'))) {
+                            fs.unlinkSync(itemPath);
+                            if (isDebugMode) {
+                                console.log(`🗑️  Removed: ${itemPath}`);
+                            }
+                        }
+                    }
+                    catch {
+                        // Ignorer les erreurs de lecture/suppression
+                    }
+                }
+                else if (isDebugMode) {
+                    console.log(`🔒 Protected file skipped: ${itemPath}`);
+                }
+            }
+        }
+    };
+    // Nettoyer les dossiers de sections
+    const sectionsToClean = ["(public)", "auth", "admin", "api"];
+    sectionsToClean.forEach((section) => {
+        const sectionPath = path.join(appDirectory, section);
+        if (fs.existsSync(sectionPath)) {
+            cleanDirectory(sectionPath);
+        }
+    });
+    // Nettoyer les fichiers générés à la racine
+    const rootFiles = ["navigation.generated.ts"];
+    rootFiles.forEach((file) => {
+        const filePath = path.join(appDirectory, file);
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+            if (isDebugMode) {
+                console.log(`🗑️  Removed: ${filePath}`);
+            }
+        }
+    });
+    if (isDebugMode) {
+        console.log("🧹 Cleanup completed");
+    }
+}
+function generateAppAside() {
+    const targetPath = path.join(appDirectory, "components", "AppAside.tsx");
+    // Ne pas écraser si le fichier existe déjà
+    if (fs.existsSync(targetPath)) {
+        if (isDebugMode) {
+            console.log(`⏭️ AppAside already exists, skipping: ${targetPath}`);
+        }
+        return;
+    }
+    const templateContent = `"use client";
+
+import { AppAside as UIAppAside } from "@lastbrain/app";
+import { useAuthSession } from "@lastbrain/app";
+import { menuConfig } from "../../config/menu";
+
+interface AppAsideProps {
+  className?: string;
+  isVisible?: boolean;
+}
+
+export function AppAside({ className = "", isVisible = true }: AppAsideProps) {
+  const { isSuperAdmin } = useAuthSession();
+
+  return (
+    <UIAppAside
+      className={className}
+      menuConfig={menuConfig}
+      isSuperAdmin={isSuperAdmin}
+      isVisible={isVisible}
+    />
+  );
+}`;
+    try {
+        ensureDirectory(path.dirname(targetPath));
+        fs.writeFileSync(targetPath, templateContent, "utf-8");
+        if (isDebugMode) {
+            console.log(`✅ Generated AppAside component: ${targetPath}`);
+        }
+    }
+    catch (error) {
+        console.error(`❌ Error generating AppAside component: ${error}`);
+    }
+}
+function generateLayouts() {
+    // Générer layout auth avec sidebar
+    const authLayoutPath = path.join(appDirectory, "auth", "layout.tsx");
+    if (!fs.existsSync(authLayoutPath)) {
+        const authLayoutContent = `import { AuthLayoutWithSidebar } from "@lastbrain/app";
+import { menuConfig } from "../../config/menu";
+
+export default function SectionLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <AuthLayoutWithSidebar menuConfig={menuConfig}>
+      {children}
+    </AuthLayoutWithSidebar>
+  );
+}`;
+        try {
+            ensureDirectory(path.dirname(authLayoutPath));
+            fs.writeFileSync(authLayoutPath, authLayoutContent, "utf-8");
+            if (isDebugMode) {
+                console.log(`✅ Generated auth layout with sidebar: ${authLayoutPath}`);
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error generating auth layout: ${error}`);
+        }
+    }
+    else if (isDebugMode) {
+        console.log(`⏭️ Auth layout already exists, skipping: ${authLayoutPath}`);
+    }
+    // Générer layout admin avec sidebar
+    const adminLayoutPath = path.join(appDirectory, "admin", "layout.tsx");
+    if (!fs.existsSync(adminLayoutPath)) {
+        const adminLayoutContent = `import { AdminLayoutWithSidebar } from "@lastbrain/app";
+import { menuConfig } from "../../config/menu";
+
+export default function AdminLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <AdminLayoutWithSidebar menuConfig={menuConfig}>
+      {children}
+    </AdminLayoutWithSidebar>
+  );
+}`;
+        try {
+            ensureDirectory(path.dirname(adminLayoutPath));
+            fs.writeFileSync(adminLayoutPath, adminLayoutContent, "utf-8");
+            if (isDebugMode) {
+                console.log(`✅ Generated admin layout with sidebar: ${adminLayoutPath}`);
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error generating admin layout: ${error}`);
+        }
+    }
+    else if (isDebugMode) {
+        console.log(`⏭️ Admin layout already exists, skipping: ${adminLayoutPath}`);
+    }
+}
+async function generateRealtimeConfig(moduleConfigs) {
+    try {
+        // Extraire les configurations realtime des modules
+        const realtimeConfigs = moduleConfigs
+            .filter((config) => config.realtime)
+            .map((config) => config.realtime);
+        if (realtimeConfigs.length === 0) {
+            console.log("⏭️ No realtime configuration found in modules");
+            return;
+        }
+        // Générer le contenu TypeScript
+        const imports = `import type { ModuleRealtimeConfig } from "@lastbrain/core";`;
+        const configData = {
+            modules: realtimeConfigs,
+            generatedAt: new Date().toISOString(),
+            version: "1.0.0",
+        };
+        const content = `${imports}
+
+// GENERATED FILE - DO NOT EDIT MANUALLY
+// Generated at: ${configData.generatedAt}
+
+export const realtimeConfig: ModuleRealtimeConfig[] = ${JSON.stringify(configData.modules, null, 2)};
+
+export default realtimeConfig;
+`;
+        // Créer le fichier de configuration
+        const outputPath = path.join(projectRoot, "config", "realtime.ts");
+        const configDir = path.dirname(outputPath);
+        // Créer le dossier config s'il n'existe pas
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+        // Écrire le fichier TypeScript
+        fs.writeFileSync(outputPath, content);
+        if (isDebugMode) {
+            console.log(`✅ Generated realtime configuration: ${outputPath}`);
+            console.log(`📊 Modules with realtime: ${realtimeConfigs.length}`);
+            // Afficher un résumé
+            realtimeConfigs.forEach((module) => {
+                console.log(`   - ${module.moduleId}: ${module.tables.length} table(s)`);
+                module.tables.forEach((table) => {
+                    console.log(`     • ${table.schema}.${table.table} (${table.event})`);
+                });
+            });
+        }
+    }
+    catch (error) {
+        console.error("❌ Error generating realtime configuration:", error);
+    }
+}
+async function generateUserTabsConfig(moduleConfigs) {
+    try {
+        // Extraire les configurations user tabs des modules
+        const userTabsConfigs = moduleConfigs
+            .filter((config) => config.userTabs && config.userTabs.length > 0)
+            .flatMap((config) => config.userTabs.map((tab) => ({
+            ...tab,
+            moduleName: config.moduleName,
+        })))
+            .sort((a, b) => (a.order || 0) - (b.order || 0));
+        let appContent;
+        if (userTabsConfigs.length === 0) {
+            console.log("⏭️ No user tabs configuration found in modules, creating empty config");
+            // Créer un fichier vide avec l'interface correcte
+            const timestamp = new Date().toISOString();
+            appContent = `// GENERATED FILE - DO NOT EDIT MANUALLY\n// User tabs configuration\n// Generated at: ${timestamp}\n\n"use client";\n\nimport type React from "react";\n\nexport interface ModuleUserTab {\n  key: string;\n  title: string;\n  icon?: string;\n  component: React.ComponentType<{ userId: string }>;\n}\n\nexport const moduleUserTabs: ModuleUserTab[] = [];\n\nexport default moduleUserTabs;\n`;
+        }
+        else {
+            // Générer les imports statiques (Next/dynamic pour chaque composant)
+            const importsForApp = userTabsConfigs
+                .map((tab) => `const ${tab.componentExport} = dynamic(() => import("${tab.moduleName}").then(mod => ({ default: mod.${tab.componentExport} })), { ssr: true });`)
+                .join("\n");
+            // Générer le tableau des tabs
+            const tabsArray = userTabsConfigs
+                .map((tab) => `  {
+    key: "${tab.key}",
+    title: "${tab.title}",
+    icon: "${tab.icon || ""}",
+    component: ${tab.componentExport},
+  }`)
+                .join(",\n");
+            const timestamp = new Date().toISOString();
+            appContent = `// GENERATED FILE - DO NOT EDIT MANUALLY\n// User tabs configuration\n// Generated at: ${timestamp}\n\n"use client";\n\nimport dynamic from "next/dynamic";\nimport type React from "react";\n\n${importsForApp}\n\nexport interface ModuleUserTab {\n  key: string;\n  title: string;\n  icon?: string;\n  component: React.ComponentType<{ userId: string }>;\n}\n\nexport const moduleUserTabs: ModuleUserTab[] = [\n${tabsArray}\n];\n\nexport default moduleUserTabs;\n`;
+        }
+        // Créer le fichier de configuration (uniquement dans /config)
+        const outputPath = path.join(projectRoot, "config", "user-tabs.ts");
+        const configDir = path.dirname(outputPath);
+        // Créer le dossier config s'il n'existe pas
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+        // Écrire le fichier TypeScript
+        fs.writeFileSync(outputPath, appContent);
+        if (isDebugMode) {
+            console.log(`✅ Generated user tabs configuration: ${outputPath}`);
+            console.log(`📊 User tabs count: ${userTabsConfigs.length}`);
+            // Afficher un résumé
+            userTabsConfigs.forEach((tab) => {
+                console.log(`   - ${tab.title} (${tab.moduleName})`);
+            });
+        }
+        // Plus de copie vers app/config ni stub core
+    }
+    catch (error) {
+        console.error("❌ Error generating user tabs configuration:", error);
+    }
+}
+async function generateBucketsConfig(moduleConfigs) {
+    try {
+        // Extraire les configurations storage des modules
+        const allBuckets = moduleConfigs
+            .filter((config) => config.storage?.buckets && config.storage.buckets.length > 0)
+            .flatMap((config) => config.storage.buckets);
+        if (allBuckets.length === 0) {
+            console.log("⏭️ No storage buckets configuration found in modules");
+            return;
+        }
+        // Générer le contenu du fichier
+        const timestamp = new Date().toISOString();
+        const bucketsEntries = allBuckets
+            .map((bucket) => {
+            // Sérialiser customAccessControl si elle existe
+            const customAccessControl = bucket.customAccessControl
+                ? `\n    customAccessControl: ${bucket.customAccessControl.toString()},`
+                : "";
+            return `  ${bucket.name}: {
+    name: "${bucket.name}",
+    isPublic: ${bucket.public},
+    description: "${bucket.description || `Storage bucket for ${bucket.name}`}",${bucket.allowedMimeTypes ? `\n    allowedFileTypes: ${JSON.stringify(bucket.allowedMimeTypes)},` : ""}${bucket.maxFileSize ? `\n    maxFileSize: ${bucket.maxFileSize}, // ${bucket.fileSizeLimit || `${Math.round(bucket.maxFileSize / 1024 / 1024)}MB`}` : ""}${customAccessControl}
+  }`;
+        })
+            .join(",\n");
+        const content = `/**
+ * Storage configuration for buckets and access control
+ * 
+ * GENERATED FILE - DO NOT EDIT MANUALLY
+ * Generated at: ${timestamp}
+ * Generated from module build configs
+ */ 
+
+export interface BucketConfig {
+  name: string;
+  isPublic: boolean;
+  description: string;
+  allowedFileTypes?: string[];
+  maxFileSize?: number; // in bytes
+  customAccessControl?: (userId: string, filePath: string) => boolean;
+}
+
+export const BUCKET_CONFIGS: Record<string, BucketConfig> = {
+${bucketsEntries}
+};
+
+/**
+ * Get bucket configuration
+ */
+export function getBucketConfig(bucketName: string): BucketConfig | null {
+  return BUCKET_CONFIGS[bucketName] || null;
+}
+
+/**
+ * Check if bucket is public
+ */
+export function isPublicBucket(bucketName: string): boolean {
+  const config = getBucketConfig(bucketName);
+  return config?.isPublic ?? false;
+}
+
+/**
+ * Check if user has access to a specific file
+ */
+export function hasFileAccess(bucketName: string, userId: string, filePath: string): boolean {
+  const config = getBucketConfig(bucketName);
+  if (!config) return false;
+
+  // Public buckets are accessible to everyone
+  if (config.isPublic) return true;
+
+  // Private buckets require authentication
+  if (!userId) return false;
+
+  // Apply custom access control if defined
+  if (config.customAccessControl) {
+    return config.customAccessControl(userId, filePath);
+  }
+
+  return true;
+}
+
+/**
+ * Validate file type for bucket
+ */
+export function isValidFileType(bucketName: string, contentType: string): boolean {
+  const config = getBucketConfig(bucketName);
+  if (!config || !config.allowedFileTypes) return true;
+
+  return config.allowedFileTypes.includes(contentType);
+}
+
+/**
+ * Check if file size is within bucket limits
+ */
+export function isValidFileSize(bucketName: string, fileSize: number): boolean {
+  const config = getBucketConfig(bucketName);
+  if (!config || !config.maxFileSize) return true;
+
+  return fileSize <= config.maxFileSize;
+}
+`;
+        // Créer le fichier dans lib/
+        const outputPath = path.join(projectRoot, "lib", "bucket-config.ts");
+        const libDir = path.dirname(outputPath);
+        // Créer le dossier lib s'il n'existe pas
+        if (!fs.existsSync(libDir)) {
+            fs.mkdirSync(libDir, { recursive: true });
+        }
+        // Écrire le fichier TypeScript
+        fs.writeFileSync(outputPath, content);
+        if (isDebugMode) {
+            console.log(`✅ Generated storage buckets configuration: ${outputPath}`);
+            console.log(`📊 Storage buckets count: ${allBuckets.length}`);
+            // Afficher un résumé
+            allBuckets.forEach((bucket) => {
+                const access = bucket.public ? "public" : "private";
+                console.log(`   - ${bucket.name} (${access})`);
+            });
+        }
+    }
+    catch (error) {
+        console.error("❌ Error generating buckets configuration:", error);
+    }
+}
+async function generateStorageProxyApi(moduleConfigs) {
+    try {
+        // Extraire les configurations storage des modules
+        const allBuckets = moduleConfigs
+            .filter((config) => config.storage?.buckets && config.storage.buckets.length > 0)
+            .flatMap((config) => config.storage.buckets);
+        if (allBuckets.length === 0) {
+            console.log("⏭️ No storage buckets found, skipping proxy API generation");
+            return;
+        }
+        // Identifier les buckets publics et privés
+        const publicBuckets = allBuckets.filter((b) => b.public);
+        const privateBuckets = allBuckets.filter((b) => !b.public);
+        // Générer les conditions pour les buckets publics
+        const publicBucketConditions = publicBuckets
+            .map((bucket) => `bucket === "${bucket.name}"`)
+            .filter(Boolean);
+        // Ajouter les conditions pour les chemins publics dans les buckets privés
+        const publicPathConditions = [];
+        if (publicBuckets.some((b) => b.name === "recipes")) {
+            publicPathConditions.push('storagePath.startsWith("recipes/")');
+        }
+        const allPublicConditions = [
+            ...publicBucketConditions,
+            ...publicPathConditions,
+        ];
+        const publicCondition = allPublicConditions.length > 0
+            ? allPublicConditions.join(" || ")
+            : "false";
+        const timestamp = new Date().toISOString();
+        const content = `import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { NextRequest, NextResponse } from "next/server";
+
+/**
+ * GET /api/storage/[bucket]/[...path]
+ * Proxy pour servir les images avec authentication
+ * 
+ * GENERATED FILE - DO NOT EDIT MANUALLY
+ * Generated at: ${timestamp}
+ * Generated from module storage configurations
+ * Buckets configurés:
+${allBuckets.map((b) => ` * - ${b.name} (${b.public ? "public" : "private"})`).join("\n")}
+ */
+export async function GET(
+  request: NextRequest,
+  context: { params: Promise<{ bucket: string; path: string[] }> },
+) {
+  try {
+    const { bucket, path } = await context.params;
+    const storagePath = path.join("/");
+
+    // Les images publiques sont accessibles sans auth
+    if (${publicCondition}) {
+      const supabase = await getSupabaseServerClient();
+      const { data, error } = await supabase.storage
+        .from(bucket)
+        .createSignedUrl(storagePath, 3600); // 1 heure
+
+      if (error) {
+        console.error(\`[storage] Error creating signed URL for public image:\`, error);
+        return new NextResponse("Not found", { status: 404 });
+      }
+
+      // Rediriger vers l'URL signée
+      return NextResponse.redirect(data.signedUrl);
+    }
+
+    // Les images privées nécessitent une authentification
+    const supabase = await getSupabaseServerClient();
+    const {
+      data: { user },
+      error: authError, 
+    } = await supabase.auth.getUser();
+
+    if (authError || !user) {
+      return new NextResponse("Unauthorized", { status: 401 });
+    }
+
+    // Cas spécial: si le chemin commence par /product/ ou /recipe/, 
+    // c'est une image avec format court qui nécessite le préfixe userId
+    let actualStoragePath = storagePath;
+    
+    if (storagePath.startsWith("product/") || storagePath.startsWith("recipe/")) {
+      actualStoragePath = \`\${user.id}/\${storagePath}\`;
+    }
+
+    // Vérifier que l'utilisateur a accès à cette image
+    // Format: {userId}/recipe/{recipeId}/{filename} ou {userId}/product/{productId}/{filename}
+    const pathParts = actualStoragePath.split("/");
+    const pathUserId = pathParts[0];
+
+    if (pathUserId !== user.id) {
+      return new NextResponse("Forbidden", { status: 403 });
+    }
+
+    // Créer une URL signée pour l'image privée
+    const { data, error } = await supabase.storage
+      .from(bucket)
+      .createSignedUrl(actualStoragePath, 3600); // 1 heure
+
+    if (error) {
+      console.error(\`[storage] Error creating signed URL:\`, error);
+      return new NextResponse("Not found", { status: 404 });
+    }
+
+    // Rediriger vers l'URL signée
+    return NextResponse.redirect(data.signedUrl);
+  } catch (error) {
+    console.error("[storage] Error:", error);
+    return new NextResponse("Internal server error", { status: 500 });
+  }
+}
+`;
+        // Créer le fichier dans app/api/storage/[bucket]/[...path]/
+        const outputPath = path.join(projectRoot, "app", "api", "storage", "[bucket]", "[...path]", "route.ts");
+        const outputDir = path.dirname(outputPath);
+        // Créer le dossier s'il n'existe pas
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        // Écrire le fichier TypeScript
+        fs.writeFileSync(outputPath, content);
+        if (isDebugMode) {
+            console.log(`✅ Generated storage proxy API: ${outputPath}`);
+            console.log(`📊 Public buckets: ${publicBuckets.map((b) => b.name).join(", ") || "none"}`);
+            console.log(`📊 Private buckets: ${privateBuckets.map((b) => b.name).join(", ") || "none"}`);
+        }
+    }
+    catch (error) {
+        console.error("❌ Error generating storage proxy API:", error);
+    }
+}
+async function generateFooterConfig(moduleConfigs) {
+    try {
+        // Extraire tous les liens footer des modules
+        const allFooterLinks = moduleConfigs
+            .filter((config) => config.footer && config.footer.length > 0)
+            .flatMap((config) => config.footer);
+        if (allFooterLinks.length === 0) {
+            console.log("⏭️ No footer links found, skipping footer config generation");
+            return;
+        }
+        // Trier les liens par position et order
+        allFooterLinks.sort((a, b) => {
+            const posOrder = { left: 0, center: 1, right: 2 };
+            const posA = posOrder[a.position || "left"] || 0;
+            const posB = posOrder[b.position || "left"] || 0;
+            if (posA !== posB)
+                return posA - posB;
+            return (a.order || 0) - (b.order || 0);
+        });
+        const timestamp = new Date().toISOString();
+        const content = `// Auto-generated footer configuration
+// Generated from module build configs
+// Generated at: ${timestamp}
+"use client";
+
+import type { FooterConfig } from "@lastbrain/ui";
+
+export const footerConfig: FooterConfig = {
+  companyName: "LastBrain",
+  companyDescription: "Plateforme de développement rapide d'applications",
+  links: ${JSON.stringify(allFooterLinks, null, 2)},
+  social: [],
+};
+`;
+        const configDir = path.join(projectRoot, "config");
+        ensureDirectory(configDir);
+        const footerPath = path.join(configDir, "footer.ts");
+        fs.writeFileSync(footerPath, content);
+        if (isDebugMode) {
+            console.log(`✅ Generated footer config: ${footerPath}`);
+            console.log(`   - ${allFooterLinks.length} footer link(s)`);
+        }
+    }
+    catch (error) {
+        console.error("❌ Error generating footer config:", error);
+    }
+}
+export async function runModuleBuild() {
+    ensureDirectory(appDirectory);
+    // Nettoyer les fichiers générés précédemment
+    if (isDebugMode) {
+        console.log("🧹 Cleaning previously generated files...");
+    }
+    cleanGeneratedFiles();
+    const moduleConfigs = await loadModuleConfigs();
+    if (isDebugMode) {
+        console.log(`🔍 Loaded ${moduleConfigs.length} module configurations`);
+    }
+    // Générer les pages
+    if (isDebugMode) {
+        console.log("\n📝 Generating pages...");
+    }
+    moduleConfigs.forEach((moduleConfig) => {
+        if (isDebugMode) {
+            console.log(`📦 Processing module: ${moduleConfig.moduleName} with ${moduleConfig.pages.length} pages`);
+        }
+        moduleConfig.pages.forEach((page) => buildPage(moduleConfig, page));
+    });
+    // Grouper les APIs par chemin pour éviter les écrasements de fichier
+    if (isDebugMode) {
+        console.log("\n🔌 Generating API routes...");
+    }
+    const apisByPath = new Map();
+    moduleConfigs.forEach((moduleConfig) => {
+        moduleConfig.apis.forEach((api) => {
+            if (!apisByPath.has(api.path)) {
+                apisByPath.set(api.path, []);
+            }
+            apisByPath.get(api.path).push({ moduleConfig, api });
+        });
+    });
+    // Générer les fichiers de route groupés
+    apisByPath.forEach((apis, routePath) => {
+        buildGroupedApi(apis, routePath);
+    });
+    dumpNavigation();
+    generateMenuConfig(moduleConfigs);
+    generateDocsPage(moduleConfigs);
+    generateAppAside();
+    generateLayouts();
+    copyModuleMigrations(moduleConfigs);
+    // Générer la configuration realtime
+    if (isDebugMode) {
+        console.log("🔄 Generating realtime configuration...");
+    }
+    await generateRealtimeConfig(moduleConfigs);
+    // Générer la configuration des user tabs
+    if (isDebugMode) {
+        console.log("📑 Generating user tabs configuration...");
+    }
+    await generateUserTabsConfig(moduleConfigs);
+    // Générer la configuration des buckets storage
+    if (isDebugMode) {
+        console.log("🗄️  Generating storage buckets configuration...");
+    }
+    await generateBucketsConfig(moduleConfigs);
+    // Générer le proxy storage API
+    if (isDebugMode) {
+        console.log("🔌 Generating storage proxy API...");
+    }
+    await generateStorageProxyApi(moduleConfigs);
+    // Générer la configuration footer
+    if (isDebugMode) {
+        console.log("🦶 Generating footer configuration...");
+    }
+    await generateFooterConfig(moduleConfigs);
+    // Message de succès final
+    if (!isDebugMode) {
+        console.log("\n✅ Module build completed successfully!");
+        console.log(`📦 ${moduleConfigs.length} module(s) processed`);
+        console.log("💡 Use --debug flag for detailed logs\n");
+    }
+    else {
+        console.log("\n✅ Module build completed (debug mode)\n");
+    }
+}