@lastbrain/app 2.0.24 → 2.0.35

package/src/scripts/module-build.ts

@@ -1,15 +1,23 @@
 import fs from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
+import { generateManifestBasedSitemaps } from "./sitemap-manifest-generator.js";
+import type { ModuleBuildConfig } from "../index.js";
 
 import type {
   ModuleApiConfig,
-  ModuleBuildConfig,
   ModuleMenuItemConfig,
   ModulePageConfig,
   ModuleSection,
   ModuleRealtimeConfig,
-} from "@lastbrain/core";
+  ModuleSitemapConfig,
+} from "../index.js";
+
+const LOCALE_MAP: Record<string, string> = {
+  fr: "fr_FR",
+  en: "en_US",
+  es: "es_ES",
+};
 
 // Utiliser PROJECT_ROOT si défini (pour pnpm --filter), sinon process.cwd()
 const projectRoot = process.env.PROJECT_ROOT || process.cwd();
@@ -248,7 +256,7 @@ function buildPage(moduleConfig: ModuleBuildConfig, page: ModulePageConfig) {
     page.componentExport === "UserPage";
 
   // Détecter les pages légales qui utilisent cookies (privacy, terms, returns)
-  const isLegalPage =
+  const _isLegalPage =
     page.section === "public" &&
     (page.path.includes("privacy") ||
       page.path.includes("terms") ||
@@ -261,6 +269,7 @@ function buildPage(moduleConfig: ModuleBuildConfig, page: ModulePageConfig) {
     // On importe directement depuis app/config au lieu de passer via props
     content = `// GENERATED BY LASTBRAIN MODULE BUILD
 import { UserDetailPage } from "${moduleConfig.moduleName}";
+import { logger } from "@lastbrain/core";
 
 interface UserPageProps { params: Promise<{ id: string }> }
 
@@ -270,7 +279,7 @@ async function getModuleUserTabs() {
     const { moduleUserTabs } = await import("../../../../../../config/user-tabs");
     return moduleUserTabs || [];
   } catch (e) {
-    console.warn("[user-detail-wrapper] erreur chargement user-tabs", e);
+    logger.warn("[user-detail-wrapper] erreur chargement user-tabs", e);
     return [];
   }
 }
@@ -292,16 +301,6 @@ const ${page.componentExport} = dynamic(
   { 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}" : ""} />;
 }
@@ -320,7 +319,7 @@ export default function ${wrapperName}${hasDynamicParams ? "(props: Record<strin
       .map((seg) => seg.slice(1, -1)); // Enlève les []
 
     // Détecter si le module path lui-même a des params dynamiques (pas seulement [lang])
-    const moduleHasDynamicParams = segments.some(
+    const _moduleHasDynamicParams = segments.some(
       (seg) => seg.startsWith("[") && seg.endsWith("]")
     );
 
@@ -338,10 +337,10 @@ export default function ${wrapperName}${hasDynamicParams ? "(props: Record<strin
     // Détecter si c'est un Server Component (entryPoint: "server")
     const isServerComponent = page.entryPoint === "server";
 
-    // Les Server Components reçoivent params en props SEULEMENT si le module lui-même a des params
+    // Les Server Components reçoivent params en props si la page a des params dynamiques
     // Les Client Components utilisent useParams() en interne
     const componentProps =
-      isServerComponent && moduleHasDynamicParams ? "params={params}" : "";
+      isServerComponent && hasDynamicParams ? "params={params}" : "";
 
     // Si params existe mais n'est pas passé au composant, on doit le unwrap quand même
     const awaitParams =
@@ -349,11 +348,49 @@ export default function ${wrapperName}${hasDynamicParams ? "(props: Record<strin
         ? "await params; // Unwrap params for Next.js 15\n  "
         : "";
 
+    // Calculer le chemin relatif correct pour locales.generated
+    // routeDir = appDirectory + sectionPath + segments
+    // on doit remonter de (sectionPath.length + segments.length) niveaux pour atteindre appDirectory
+    // puis accéder à config/locales.generated
+    const pathDepth = sectionPath.length + segments.length;
+    const localeImportPath =
+      Array(pathDepth + 1)
+        .fill("..")
+        .join("/") + "/config/locales.generated";
+
+    // Pour les pages publiques (section: "public"), importer et passer LOCALE_CONFIG
+    const localeImport =
+      page.section === "public"
+        ? `\nimport { LOCALE_CONFIG } from "${localeImportPath}";\n`
+        : "";
+
+    const localeProps =
+      page.section === "public" && isServerComponent
+        ? "localeConfig={LOCALE_CONFIG}"
+        : "";
+
+    const allComponentProps = [componentProps, localeProps]
+      .filter(Boolean)
+      .join(" ");
+
+    // Pour les pages publiques avec metadataExport, créer une fonction wrapper qui passe LOCALE_CONFIG
+    // On utilise un alias pour l'import afin d'éviter le conflit de nom avec la fonction exportée
+    const metadataImportAlias = page.metadataExport
+      ? `${page.metadataExport} as ${page.metadataExport}Original`
+      : "";
+    const metadataExport =
+      page.section === "public" && page.metadataExport && localeImport
+        ? `\nexport async function generateMetadata(props: any) {
+  return ${page.metadataExport}Original({ ...props, localeConfig: LOCALE_CONFIG });
+}`
+        : page.metadataExport
+          ? `\nexport { ${page.metadataExport}Original as generateMetadata };`
+          : "";
+
     content = `// GENERATED BY LASTBRAIN MODULE BUILD
-import { ${page.componentExport} } from "${importPath}";
-${page.metadataExport ? `\nexport { ${page.metadataExport} as generateMetadata } from "${importPath}";\n` : ""}
+import { ${page.componentExport}${page.metadataExport ? `, ${metadataImportAlias}` : ""} } from "${importPath}";${localeImport}${metadataExport}
 export default ${hasDynamicParams ? "async " : ""}function ${wrapperName}${propsSignature} {
-  ${awaitParams}return <${page.componentExport} ${componentProps} />;
+  ${awaitParams}return <${page.componentExport} ${allComponentProps} />;
 }
 `;
   }
@@ -511,10 +548,12 @@ export interface MenuItem {
   shortcut?: string;
   shortcutDisplay?: string;
   type?: 'text' | 'icon' | 'textIcon';
+  keyboardOnly?: boolean;
   position?: 'center' | 'end';
   component?: React.ComponentType<any>;
   componentExport?: string;
   entryPoint?: string;
+  badge?: string;
 }
 
 export interface MenuConfig {
@@ -647,7 +686,7 @@ function copyModuleMigrations(moduleConfigs: ModuleBuildConfig[]) {
 }
 
 function generateDocsPage(moduleConfigs: ModuleBuildConfig[]) {
-  const docsDir = path.join(appDirectory, "docs");
+  const docsDir = path.join(appDirectory, "[lang]", "(public)", "docs");
   ensureDirectory(docsDir);
 
   const docsPagePath = path.join(docsDir, "page.tsx");
@@ -675,13 +714,13 @@ function generateDocsPage(moduleConfigs: ModuleBuildConfig[]) {
 
   allModules.forEach((moduleEntry) => {
     const moduleName = moduleEntry.package;
-    // Extraire le nom du module sans le scope et sans "module-"
+    // Extraire le nom du module sans le scope et sans "-pro"
     // Ex: @lastbrain/module-auth -> auth
-    // Ex: @lastbrain-labs/module-recipes-pro -> recipes
+    // Ex: @lastbrain-labs/module-metrics-pro -> metrics
     const moduleId = moduleName
       .replace("@lastbrain-labs/module-", "")
       .replace("@lastbrain/module-", "")
-      .replace(/-pro$/, ""); // Retirer le suffix -pro pour avoir le nom de base
+      .replace(/-pro$/, ""); // Retirer le suffixe -pro
 
     const docComponentName = `${toPascalCase(moduleId)}ModuleDoc`;
 
@@ -733,6 +772,45 @@ ${moduleConfigurations.join(",\n")}
   if (isDebugMode) {
     console.log(`📚 Generated docs page: ${docsPagePath}`);
   }
+
+  // Generate docs layout with translation support
+  const docsLayoutPath = path.join(docsDir, "layout.tsx");
+  const docsLayoutContent = `// Auto-generated docs layout with translation support
+import { loadTranslations } from "@lastbrain/app/i18n/server-lang";
+import { ClientLayout } from "../../../../components/ClientLayout";
+import { headers } from "next/headers";
+
+// Extract language from request headers
+async function getLanguageFromRequest(): Promise<string> {
+  const headersList = await headers();
+  const acceptLanguage = headersList.get("accept-language") || "";
+  // Detect if French is requested
+  if (acceptLanguage.toLowerCase().includes("fr")) {
+    return "fr";
+  }
+  return "en";
+}
+
+export default async function DocsLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  const lang = await getLanguageFromRequest();
+  const translations = await loadTranslations(lang);
+
+  return (
+    <ClientLayout lang={lang} translations={translations}>
+      <div className="min-h-screen pt-12">{children}</div>
+    </ClientLayout>
+  );
+}
+`;
+
+  fs.writeFileSync(docsLayoutPath, docsLayoutContent);
+  if (isDebugMode) {
+    console.log(`📚 Generated docs layout: ${docsLayoutPath}`);
+  }
 }
 
 function buildGroupedApi(
@@ -799,7 +877,8 @@ function cleanGeneratedFiles() {
     "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
+    "[lang]/(public)/docs/page.tsx", // Page docs générée
+    "[lang]/(public)/docs/layout.tsx", // Layout docs généré
     // Middleware et autres fichiers core
     "middleware.ts",
     // Dossiers de lib et config
@@ -878,7 +957,14 @@ function cleanGeneratedFiles() {
   };
 
   // Nettoyer les dossiers de sections
-  const sectionsToClean = ["(public)", "auth", "admin", "api", "[lang]"];
+  const sectionsToClean = [
+    "(public)",
+    "auth",
+    "admin",
+    "api",
+    "[lang]",
+    "sitemap",
+  ];
   sectionsToClean.forEach((section) => {
     const sectionPath = path.join(appDirectory, section);
     if (fs.existsSync(sectionPath)) {
@@ -954,7 +1040,7 @@ function cleanOldRoutesWithoutLang() {
     }
   });
 }
-function generateAppAside() {
+function _generateAppAside() {
   const targetPath = path.join(appDirectory, "components", "AppAside.tsx");
   const templateContent = `"use client";
 
@@ -987,10 +1073,15 @@ export function AppAside({ className = "", isVisible = true }: AppAsideProps) {
   }
 }
 
-function generateLayouts() {
-  // Générer ClientLayout wrapper client
+function generateLayouts(moduleConfigs: ModuleBuildConfig[]) {
+  // Vérifier si le module billing-pro est actif
+  const hasBillingModule = moduleConfigs.some(
+    (config) => config.moduleName === "@lastbrain-labs/module-billing-pro"
+  );
+
+  // Générer ClientLayout wrapper client (dans components/ racine)
   const clientLayoutPath = path.join(
-    appDirectory,
+    projectRoot,
     "components",
     "ClientLayout.tsx"
   );
@@ -1008,10 +1099,12 @@ export function ClientLayout({
   children,
   lang = "fr",
   translations = {},
+  availableLanguages = ["fr", "en"],
 }: {
   children: ReactNode;
   lang?: Language;
   translations?: Record<string, string>;
+  availableLanguages?: string[];
 }) {
   const router = useLocalizedRouter();
 
@@ -1023,7 +1116,7 @@ export function ClientLayout({
         enableSystem={false}
         storageKey="lastbrain-theme"
       >
-        <AppProviders lang={lang} translations={translations}>
+        <AppProviders lang={lang} translations={translations} availableLanguages={availableLanguages}>
           <AppHeader />
           <div className="min-h-screen text-foreground bg-background">
             {children}
@@ -1044,33 +1137,49 @@ export function ClientLayout({
     console.error(`❌ Error generating ClientLayout component: ${error}`);
   }
 
-  // Générer AppProviders wrapper client
+  // Générer AppProviders wrapper client (dans components/ racine)
   const appProvidersPath = path.join(
-    appDirectory,
+    projectRoot,
     "components",
     "AppProviders.tsx"
   );
+
+  // Import conditionnel de EntitlementsProvider
+  const entitlementsImport = hasBillingModule
+    ? `import { EntitlementsProvider } from "@lastbrain-labs/module-billing-pro";`
+    : "";
+
+  // Prop conditionnel pour EntitlementsProviderComponent
+  const entitlementsProp = hasBillingModule
+    ? `EntitlementsProviderComponent={EntitlementsProvider}`
+    : "";
+
   const appProvidersContent = `"use client";
 
 import { AppProviders as BaseAppProviders } from "@lastbrain/app";
-import { realtimeConfig } from "../../config/realtime";
+${entitlementsImport}
+import { realtimeConfig } from "../config/realtime";
 import type { ReactNode } from "react";
 import type { Language } from "@lastbrain/core";
 
 export function AppProviders({
-  children,
+  children, 
   lang = "fr",
   translations = {},
+  availableLanguages = ["fr", "en"],
 }: {
   children: ReactNode;
   lang?: Language;
   translations?: Record<string, string>;
+  availableLanguages?: string[];
 }) {
   return (
     <BaseAppProviders
       realtimeConfig={realtimeConfig}
       lang={lang}
       translations={translations}
+      availableLanguages={availableLanguages}
+      ${entitlementsProp}
     >
       {children}
     </BaseAppProviders>
@@ -1087,19 +1196,33 @@ export function AppProviders({
     console.error(`❌ Error generating AppProviders component: ${error}`);
   }
 
-  // Générer AppHeader component
-  const appHeaderPath = path.join(appDirectory, "components", "AppHeader.tsx");
+  // Générer AppHeader component (dans components/ racine)
+  const appHeaderPath = path.join(projectRoot, "components", "AppHeader.tsx");
   const appHeaderContent = `"use client";
 
 import { Header } from "@lastbrain/ui";
-import { LanguageSwitcher } from "@lastbrain/app";
-import { menuConfig } from "../../config/menu";
+import { LanguageSwitcher, useAuth } from "@lastbrain/app";
+import { menuConfig } from "../config/menu";
+import { menuIgnored } from "../config/menu-ignored";
+import { LOCALE_CONFIG } from "../config/locales.generated";
 
 export function AppHeader() {
+  const { user, loading, isSuperAdmin } = useAuth();
+
   return (
     <Header
+      user={user}
+      isSuperAdmin={isSuperAdmin}
       menuConfig={menuConfig}
-      languageSwitcher={<LanguageSwitcher variant="minimal" />}
+      accountMenu={menuConfig.account}
+      menuIgnored={menuIgnored}
+      languageSwitcher={
+        <LanguageSwitcher
+          variant="minimal"
+          availableLanguages={[...LOCALE_CONFIG.languages]}
+          localeMap={LOCALE_CONFIG.localeMap}
+        />
+      }
     />
   );
 }`;
@@ -1116,6 +1239,27 @@ export function AppHeader() {
     const langLayoutContent = `import { loadTranslations } from "@lastbrain/app/i18n/server-lang";
 import { ClientLayout } from "../../components/ClientLayout";
 
+// Fallback default config in case locales.generated.ts is not available
+const DEFAULT_LOCALE_CONFIG = {
+  languages: ["fr", "en"] as const,
+  locales: ["fr_FR", "en_US"],
+  localeMap: { fr: "fr_FR", en: "en_US" } as Record<string, string>,
+};
+
+// Type for valid languages derived from config
+type ValidLanguage = (typeof DEFAULT_LOCALE_CONFIG.languages)[number];
+
+// Helper function to safely load locale config
+async function getLocaleConfig() {
+
+    const importedConfig = await import("../../config/locales.generated");
+    if (importedConfig?.LOCALE_CONFIG && importedConfig.LOCALE_CONFIG.languages) {
+      return importedConfig.LOCALE_CONFIG;
+    }
+ 
+  return DEFAULT_LOCALE_CONFIG;
+}
+
 export default async function LangLayout({
   children,
   params,
@@ -1124,14 +1268,23 @@ export default async function LangLayout({
   params: Promise<{ lang: string }>;
 }) {
   const { lang } = await params;
-  const validLang = lang === "en" || lang === "fr" ? lang : "fr";
+
+  // Get the locale config (either from app or fallback)
+  const LOCALE_CONFIG = await getLocaleConfig();
+
+  // Validate lang and cast to ValidLanguage type
+  const isValidLang = (val: string): val is ValidLanguage => {
+    return LOCALE_CONFIG.languages.includes(val as any);
+  };
+
+  const validLang: ValidLanguage = isValidLang(lang) ? lang : "fr";
   
   // Charger les traductions pour cette langue
   const translations = await loadTranslations(validLang);
   
   return (
-    <ClientLayout lang={validLang} translations={translations}>
-      <div className="min-h-screen pt-16">
+    <ClientLayout lang={validLang} translations={translations} availableLanguages={[...LOCALE_CONFIG.languages]}>
+      <div className="min-h-screen ">
         {children}
       </div>
     </ClientLayout>
@@ -1162,6 +1315,7 @@ export default async function LangLayout({
 
 import { AuthLayoutWithSidebar, langHref, useLanguage } from "@lastbrain/app";
 import { menuConfig as fullMenuConfig } from "../../../config/menu";
+import { menuIgnored } from "../../../config/menu-ignored";
 
 export default function SectionLayout({
   children,
@@ -1182,7 +1336,7 @@ export default function SectionLayout({
   };
 
   return (
-    <AuthLayoutWithSidebar menuConfig={menuConfig}>
+    <AuthLayoutWithSidebar menuConfig={menuConfig} menuIgnored={menuIgnored}>
       {children}
     </AuthLayoutWithSidebar>
   );
@@ -1198,6 +1352,39 @@ export default function SectionLayout({
     console.error(`❌ Error generating auth layout: ${error}`);
   }
 
+  // Générer layout public avec footer
+  const publicLayoutPath = path.join(
+    appDirectory,
+    "[lang]",
+    "(public)",
+    "layout.tsx"
+  );
+  const publicLayoutContent = `"use client";
+
+import type React from "react";
+import { PublicLayout } from "@lastbrain/app";
+import { footerConfig } from "../../../config/footer";
+
+export default function PublicSectionLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return <PublicLayout footerConfig={footerConfig}>
+      {children}
+    </PublicLayout>;
+}`;
+
+  try {
+    writeScaffoldFile(
+      publicLayoutPath,
+      publicLayoutContent,
+      "public layout with footer"
+    );
+  } catch (error) {
+    console.error(`❌ Error generating public layout: ${error}`);
+  }
+
   // Générer layout admin avec sidebar
   const adminLayoutPath = path.join(
     appDirectory,
@@ -1209,6 +1396,7 @@ export default function SectionLayout({
 
 import { AdminLayoutWithSidebar, langHref, useLanguage } from "@lastbrain/app";
 import { menuConfig as fullMenuConfig } from "../../../config/menu";
+import { menuIgnored } from "../../../config/menu-ignored";
 
 export default function AdminLayout({
   children,
@@ -1229,7 +1417,7 @@ export default function AdminLayout({
   };
 
   return (
-    <AdminLayoutWithSidebar menuConfig={menuConfig}>
+    <AdminLayoutWithSidebar menuConfig={menuConfig} menuIgnored={menuIgnored}>
       {children}
     </AdminLayoutWithSidebar>
   );
@@ -1333,10 +1521,12 @@ async function generateUserTabsConfig(moduleConfigs: ModuleBuildConfig[]) {
     } 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 });`
-        )
+        .map((tab) => {
+          // UserTokenTab est un Client Component, utiliser ssr: false
+          const ssrMode =
+            tab.componentExport === "UserTokenTab" ? "false" : "true";
+          return `const ${tab.componentExport} = dynamic(() => import("${tab.moduleName}").then(mod => ({ default: mod.${tab.componentExport} })), { ssr: ${ssrMode} });`;
+        })
         .join("\n");
 
       // Générer le tableau des tabs
@@ -1383,6 +1573,157 @@ async function generateUserTabsConfig(moduleConfigs: ModuleBuildConfig[]) {
   }
 }
 
+async function generateAuthDashboard(moduleConfigs: ModuleBuildConfig[]) {
+  try {
+    const dashboards = moduleConfigs
+      .flatMap((config) =>
+        (config.authDashboard ?? []).map((dashboard) => ({
+          ...dashboard,
+          moduleName: config.moduleName,
+        }))
+      )
+      .sort((a, b) => (a.order ?? 999) - (b.order ?? 999));
+
+    const timestamp = new Date().toISOString();
+
+    let configContent: string;
+
+    if (dashboards.length === 0) {
+      configContent = `// GENERATED FILE - DO NOT EDIT MANUALLY
+// Auth dashboard configuration
+// Generated at: ${timestamp}
+
+"use client";
+
+import type React from "react";
+
+export interface ModuleAuthDashboard {
+  key: string;
+  title: string;
+  icon?: string;
+  order?: number;
+  component: React.ComponentType<Record<string, never>>;
+}
+
+export const moduleAuthDashboards: ModuleAuthDashboard[] = [];
+
+export default moduleAuthDashboards;
+`;
+    } else {
+      const dynamicImports = dashboards
+        .map(
+          (dashboard, index) =>
+            `const AuthDashboardComponent${index} = dynamic(() => import("${dashboard.moduleName}").then(mod => ({ default: (mod as any)["${dashboard.componentExport}"] })), { ssr: true });`
+        )
+        .join("\n");
+
+      const dashboardsArray = dashboards
+        .map(
+          (dashboard, index) => `  {
+    key: "${dashboard.key}",
+    title: "${dashboard.title}",
+    icon: "${dashboard.icon ?? ""}",
+    order: ${dashboard.order ?? 999},
+    component: AuthDashboardComponent${index},
+  }`
+        )
+        .join(",\n");
+
+      configContent = `// GENERATED FILE - DO NOT EDIT MANUALLY
+// Auth dashboard configuration
+// Generated at: ${timestamp}
+
+"use client";
+
+import dynamic from "next/dynamic";
+import type React from "react";
+
+${dynamicImports}
+
+export interface ModuleAuthDashboard {
+  key: string;
+  title: string;
+  icon?: string;
+  order?: number;
+  component: React.ComponentType<Record<string, never>>;
+}
+
+export const moduleAuthDashboards: ModuleAuthDashboard[] = [
+${dashboardsArray}
+];
+
+export default moduleAuthDashboards;
+`;
+    }
+
+    const configPath = path.join(projectRoot, "config", "auth-dashboard.ts");
+    ensureDirectory(path.dirname(configPath));
+    fs.writeFileSync(configPath, configContent);
+
+    if (isDebugMode) {
+      console.log(
+        `✅ Generated auth dashboard configuration: ${configPath} (${dashboards.length} item(s))`
+      );
+    }
+
+    const pagePath = path.join(
+      appDirectory,
+      "[lang]",
+      "auth",
+      "dashboard",
+      "page.tsx"
+    );
+
+    ensureDirectory(path.dirname(pagePath));
+
+    const pageContent = `// GENERATED BY LASTBRAIN MODULE BUILD
+"use client";
+
+import { Suspense } from "react";
+import { moduleAuthDashboards } from "../../../../config/auth-dashboard";
+
+export const dynamic = "force-dynamic";
+
+
+export default function AuthDashboardPage() {
+  const dashboards = moduleAuthDashboards || [];
+
+  if (dashboards.length === 0) {
+    return <div className="space-y-4">Aucun dashboard disponible.</div>;
+  }
+
+  return (
+    <div className="space-y-6">
+      {dashboards.map((dashboard) => {
+      
+        const Component = dashboard.component;
+
+        return (
+          <section
+            key={dashboard.key}
+
+          >
+            <Suspense fallback={<div>Chargement...</div>}>
+              <Component />
+            </Suspense>
+          </section>
+        );
+      })}
+    </div>
+  );
+}
+`;
+
+    fs.writeFileSync(pagePath, pageContent);
+
+    if (isDebugMode) {
+      console.log(`🧭 Generated auth dashboard page: ${pagePath}`);
+    }
+  } catch (error) {
+    console.error("❌ Error generating auth dashboard configuration:", error);
+  }
+}
+
 async function generateBucketsConfig(moduleConfigs: ModuleBuildConfig[]) {
   try {
     // Extraire les configurations storage des modules
@@ -1583,7 +1924,6 @@ export async function GET(
         .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 });
       }
 
@@ -1604,16 +1944,23 @@ export async function GET(
 
     // 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
+    // Sinon le chemin contient déjà le userId
     let actualStoragePath = storagePath;
-    
-    if (storagePath.startsWith("product/") || storagePath.startsWith("recipe/")) {
+    const pathParts = storagePath.split("/");
+
+    // Vérifier si le premier segment est un UUID (userId déjà présent)
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    const firstSegmentIsUuid = uuidRegex.test(pathParts[0]);
+
+    if (!firstSegmentIsUuid) {
+      // Le chemin ne contient pas le userId, on l'ajoute
       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];
+    const actualPathParts = actualStoragePath.split("/");
+    const pathUserId = actualPathParts[0];
 
     if (pathUserId !== user.id) {
       return new NextResponse("Forbidden", { status: 403 });
@@ -1622,17 +1969,31 @@ export async function GET(
     // Créer une URL signée pour l'image privée
     const { data, error } = await supabase.storage
       .from(bucket)
-      .createSignedUrl(actualStoragePath, 3600); // 1 heure
+      .createSignedUrl(actualStoragePath, 60); // 1 minute seulement
 
     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);
+    // Télécharger l'image et la retourner avec des headers no-cache
+    const imageResponse = await fetch(data.signedUrl);
+    if (!imageResponse.ok) {
+      return new NextResponse("Not found", { status: 404 });
+    }
+
+    const imageBuffer = await imageResponse.arrayBuffer();
+    const contentType = imageResponse.headers.get("content-type") || "image/jpeg";
+
+    return new NextResponse(imageBuffer, {
+      status: 200,
+      headers: {
+        "Content-Type": contentType,
+        "Cache-Control": "no-cache, no-store, must-revalidate",
+        "Pragma": "no-cache",
+        "Expires": "0",
+      },
+    });
   } catch (error) {
-    console.error("[storage] Error:", error);
     return new NextResponse("Internal server error", { status: 500 });
   }
 }
@@ -1704,8 +2065,6 @@ async function generateFooterConfig(moduleConfigs: ModuleBuildConfig[]) {
 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: [],
 };
@@ -1726,11 +2085,364 @@ export const footerConfig: FooterConfig = {
   }
 }
 
+/**
+ * Génère les routes sitemap à partir des configurations des modules
+ */
+async function generateSitemapRoutes(moduleConfigs: ModuleBuildConfig[]) {
+  try {
+    // Collecter tous les sitemaps de tous les modules
+    const allSitemaps: Array<{
+      moduleConfig: ModuleBuildConfig;
+      sitemap: ModuleSitemapConfig;
+    }> = [];
+
+    moduleConfigs.forEach((config) => {
+      if (config.sitemaps && config.sitemaps.length > 0) {
+        config.sitemaps.forEach((sitemap) => {
+          allSitemaps.push({ moduleConfig: config, sitemap });
+        });
+      }
+    });
+
+    if (allSitemaps.length === 0) {
+      if (isDebugMode) {
+        console.log("⏭️ No sitemaps found, skipping sitemap generation");
+      }
+      return;
+    }
+
+    // Détecter les sitemaps index des modules (sitemap.xml ou sitemap-index)
+    const moduleSitemapIndexes: string[] = [];
+
+    // Renommer les /sitemap.xml en /sitemap-{moduleName}.xml pour éviter les conflits
+    allSitemaps.forEach(({ moduleConfig, sitemap }) => {
+      if (
+        sitemap.path === "/sitemap.xml" ||
+        sitemap.path.endsWith("-index.xml")
+      ) {
+        // Extraire le nom court du module (ex: module-blog -> blog)
+        const moduleShortName = moduleConfig.moduleName
+          .replace("@lastbrain/", "")
+          .replace("@lastbrain-labs/", "")
+          .replace("module-", "")
+          .replace("module-core-", "");
+
+        // Renommer le path
+        sitemap.path = `/sitemap-${moduleShortName}.xml`;
+        moduleSitemapIndexes.push(sitemap.path);
+
+        if (isDebugMode) {
+          console.log(
+            `🔄 Renamed sitemap from /sitemap.xml to ${sitemap.path} for ${moduleConfig.moduleName}`
+          );
+        }
+      }
+    });
+
+    // Générer chaque route sitemap
+    for (const { moduleConfig, sitemap } of allSitemaps) {
+      const sitemapPath = sitemap.path;
+
+      // Déterminer le chemin du fichier route.ts
+      let routeDir: string;
+      if (sitemapPath === "/sitemap.xml") {
+        // Route principale sitemap.xml à la racine de app
+        routeDir = path.join(appDirectory, "sitemap.xml");
+      } else {
+        // Sous-sitemaps (ex: /sitemap/recipes.xml -> app/sitemap/recipes.xml)
+        const segments = sitemapPath
+          .replace(/^\//, "")
+          .replace(/\.xml$/, ".xml")
+          .split("/");
+        routeDir = path.join(appDirectory, ...segments);
+      }
+
+      const routeFilePath = path.join(routeDir, "route.ts");
+      ensureDirectory(routeDir);
+
+      // Déterminer le type de sitemap et générer le code approprié
+      const entryPoint = sitemap.entryPoint;
+      let content: string;
+
+      if (entryPoint === "sitemap/index") {
+        // Sitemap index principal
+        content = `// GENERATED BY LASTBRAIN MODULE BUILD - Sitemap Index Route
+// Module: ${moduleConfig.moduleName}
+// Path: ${sitemapPath}
+import { generateSitemapIndex } from "${moduleConfig.moduleName}/sitemap";
+
+export async function GET(): Promise<Response> {
+  const baseUrl = process.env.NEXT_PUBLIC_SITE_URL || (process.env.VERCEL_URL ? \`https://\${process.env.VERCEL_URL}\` : "https://example.com");
+
+  // Liste des sous-sitemaps
+  const sitemapPaths = [
+    "/sitemap/pages.xml",
+    "/sitemap/recipes.xml",
+    "/sitemap/chefs.xml",
+  ];
+
+  const xml = generateSitemapIndex(baseUrl, sitemapPaths);
+
+  return new Response(xml, {
+    headers: {
+      "Content-Type": "application/xml",
+      "Cache-Control": "public, max-age=3600, s-maxage=3600",
+    },
+  });
+}
+`;
+      } else if (entryPoint === "sitemap/pages") {
+        // Sitemap des pages statiques
+        content = `// GENERATED BY LASTBRAIN MODULE BUILD - Static Pages Sitemap Route
+// Module: ${moduleConfig.moduleName}
+// Path: ${sitemapPath}
+import { generateStaticPagesSitemap, generateSitemapXml } from "${moduleConfig.moduleName}/sitemap";
+
+export async function GET(): Promise<Response> {
+  const baseUrl = process.env.NEXT_PUBLIC_SITE_URL || (process.env.VERCEL_URL ? \`https://\${process.env.VERCEL_URL}\` : "https://example.com");
+
+  const sitemap = await generateStaticPagesSitemap(baseUrl);
+  const xml = generateSitemapXml(sitemap);
+
+  return new Response(xml, {
+    headers: {
+      "Content-Type": "application/xml",
+      "Cache-Control": "public, max-age=86400, s-maxage=86400",
+    },
+  });
+}
+`;
+      } else if (entryPoint === "sitemap/recipes") {
+        // Sitemap des recettes
+        content = `// GENERATED BY LASTBRAIN MODULE BUILD - Recipes Sitemap Route
+// Module: ${moduleConfig.moduleName}
+// Path: ${sitemapPath}
+import { generateRecipesSitemap, generateSitemapXml } from "${moduleConfig.moduleName}/sitemap";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+
+export async function GET(): Promise<Response> {
+  const baseUrl = process.env.NEXT_PUBLIC_SITE_URL || (process.env.VERCEL_URL ? \`https://\${process.env.VERCEL_URL}\` : "https://example.com");
+  const supabase = await getSupabaseServiceClient();
+
+  const sitemap = await generateRecipesSitemap(baseUrl, supabase);
+  const xml = generateSitemapXml(sitemap);
+
+  return new Response(xml, {
+    headers: {
+      "Content-Type": "application/xml",
+      "Cache-Control": "public, max-age=3600, s-maxage=3600",
+    },
+  });
+}
+`;
+      } else if (entryPoint === "sitemap/chefs") {
+        // Sitemap des chefs
+        content = `// GENERATED BY LASTBRAIN MODULE BUILD - Chefs Sitemap Route
+// Module: ${moduleConfig.moduleName}
+// Path: ${sitemapPath}
+import { generateChefsSitemap, generateSitemapXml } from "${moduleConfig.moduleName}/sitemap";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+
+export async function GET(): Promise<Response> {
+  const baseUrl = process.env.NEXT_PUBLIC_SITE_URL || (process.env.VERCEL_URL ? \`https://\${process.env.VERCEL_URL}\` : "https://example.com");
+  const supabase = await getSupabaseServiceClient();
+
+  const sitemap = await generateChefsSitemap(baseUrl, supabase);
+  const xml = generateSitemapXml(sitemap);
+
+  return new Response(xml, {
+    headers: {
+      "Content-Type": "application/xml",
+      "Cache-Control": "public, max-age=3600, s-maxage=3600",
+    },
+  });
+}
+`;
+      } else {
+        // Sitemap générique - export direct du handler
+        content = `// GENERATED BY LASTBRAIN MODULE BUILD - Sitemap route
+// Module: ${moduleConfig.moduleName}
+// Path: ${sitemapPath}
+export { ${sitemap.handlerExport} } from "${moduleConfig.moduleName}/${sitemap.entryPoint}";
+`;
+      }
+
+      fs.writeFileSync(routeFilePath, content);
+
+      if (isDebugMode) {
+        console.log(`🗺️  Generated sitemap route: ${routeFilePath}`);
+      }
+    }
+
+    // Générer le sitemap.xml global qui agrège tous les sitemaps des modules
+    if (moduleSitemapIndexes.length > 0) {
+      const globalSitemapDir = path.join(appDirectory, "sitemap.xml");
+      const globalSitemapFile = path.join(globalSitemapDir, "route.ts");
+      ensureDirectory(globalSitemapDir);
+
+      const sitemapUrls = moduleSitemapIndexes
+        .map((path) => {
+          return `    {
+      url: \`\${baseUrl}${path}\`,
+      lastModified: new Date(),
+    }`;
+        })
+        .join(",\n");
+
+      const globalSitemapContent = `// GENERATED BY LASTBRAIN MODULE BUILD - Global Sitemap Index
+// This file aggregates all module sitemaps
+// Module sitemaps: ${moduleSitemapIndexes.join(", ")}
+
+export async function GET(): Promise<Response> {
+  const baseUrl = process.env.NEXT_PUBLIC_SITE_URL || (process.env.VERCEL_URL ? \`https://\${process.env.VERCEL_URL}\` : "https://example.com");
+
+  const sitemapIndexXml = \`<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${moduleSitemapIndexes
+  .map(
+    (path) => `  <sitemap>
+    <loc>\${baseUrl}${path}</loc>
+    <lastmod>\${new Date().toISOString()}</lastmod>
+  </sitemap>`
+  )
+  .join("\n")}
+</sitemapindex>\`;
+
+  return new Response(sitemapIndexXml, {
+    headers: {
+      "Content-Type": "application/xml",
+      "Cache-Control": "public, max-age=3600, s-maxage=3600",
+    },
+  });
+}
+`;
+
+      fs.writeFileSync(globalSitemapFile, globalSitemapContent);
+
+      if (isDebugMode) {
+        console.log(
+          `🌍 Generated global sitemap.xml aggregating ${moduleSitemapIndexes.length} module sitemap(s)`
+        );
+      }
+    }
+
+    if (isDebugMode) {
+      console.log(`✅ Generated ${allSitemaps.length} sitemap route(s)`);
+    }
+  } catch (error) {
+    console.error("❌ Error generating sitemap routes:", error);
+  }
+}
+
 /**
  * Génère les fichiers i18n en concaténant les traductions des modules
+ * et en incluant les traductions personnalisées de i18n/default
  */
+async function generateLocaleConfig() {
+  const appI18nDir = path.join(projectRoot, "i18n");
+  const appConfigDir = path.join(projectRoot, "config");
+
+  try {
+    // Scanner les fichiers i18n disponibles
+    let languages: string[] = ["fr"]; // Fallback par défaut
+
+    if (fs.existsSync(appI18nDir)) {
+      const files = fs.readdirSync(appI18nDir);
+      languages = files
+        .filter((f) => f.endsWith(".json"))
+        .map((f) => f.replace(".json", ""))
+        .filter((lang) => LOCALE_MAP[lang])
+        .sort();
+
+      if (isDebugMode) {
+        console.log(`  📋 Detected languages: ${languages.join(", ")}`);
+      }
+    }
+
+    const locales = languages.map((lang) => LOCALE_MAP[lang]);
+    const localeMap = languages.reduce(
+      (acc, lang) => {
+        acc[lang] = LOCALE_MAP[lang];
+        return acc;
+      },
+      {} as Record<string, string>
+    );
+
+    // Générer le fichier TypeScript dans l'app (ex: apps/recipe/config/)
+    ensureDirectory(appConfigDir);
+
+    // Générer le fichier dans config/
+    const outputPath = path.join(appConfigDir, "locales.generated.ts");
+    const content = `// This file is auto-generated by module-build.ts
+// Do not edit manually - regenerate with 'pnpm build:modules'
+
+export interface LocaleConfig {
+  languages: string[];
+  locales: string[];
+  localeMap: Record<string, string>;
+}
+
+export const LOCALE_CONFIG: LocaleConfig = ${JSON.stringify(
+      {
+        languages,
+        locales,
+        localeMap,
+      },
+      null,
+      2
+    )} as const;
+
+/**
+ * Convert language code to locale (e.g., "fr" -> "fr_FR")
+ */
+export function langToLocale(lang: string): string {
+  return LOCALE_CONFIG.localeMap[lang] || "fr_FR";
+}
+
+/**
+ * Get all locales except the given one
+ */
+export function getAlternateLocales(lang: string): string[] {
+  const currentLocale = LOCALE_CONFIG.localeMap[lang] || "fr_FR";
+  return LOCALE_CONFIG.locales.filter((l) => l !== currentLocale);
+}
+
+/**
+ * Get locale map for metadata generation
+ */
+export function getLocaleMap(): Record<string, string> {
+  return LOCALE_CONFIG.localeMap;
+}
+`;
+
+    writeScaffoldFile(outputPath, content, "locale configuration");
+
+    // Générer aussi un fichier de ré-export dans le répertoire racine de l'app pour faciliter l'import
+    const rootExportPath = path.join(projectRoot, "locale-helpers.ts");
+    const rootExportContent = `// Re-export locale helpers from config for easy import in packages
+export { langToLocale, getAlternateLocales, getLocaleMap, LOCALE_CONFIG } from "./config/locales.generated";
+export type { LocaleConfig } from "./config/locales.generated";
+`;
+
+    writeScaffoldFile(
+      rootExportPath,
+      rootExportContent,
+      "locale helpers re-export"
+    );
+
+    if (isDebugMode) {
+      console.log(
+        `  ✅ Generated locale config with ${languages.length} language(s)`
+      );
+    }
+  } catch (error) {
+    console.error("❌ Error generating locale config:", error);
+  }
+}
+
 async function generateI18nFiles() {
   const appI18nDir = path.join(projectRoot, "i18n");
+  const appI18nDefaultDir = path.join(projectRoot, "i18n", "default");
   const packagesDir = path.join(_monorepoRoot, "packages");
 
   interface TranslationMap {
@@ -1793,6 +2505,41 @@ async function generateI18nFiles() {
       }
     }
 
+    // Charger les traductions personnalisées de i18n/default
+    if (fs.existsSync(appI18nDefaultDir)) {
+      // Découvrir dynamiquement les fichiers de langue disponibles
+      const defaultFiles = fs
+        .readdirSync(appI18nDefaultDir)
+        .filter((file) => file.endsWith(".json"));
+
+      for (const defaultFile of defaultFiles) {
+        const defaultFilePath = path.join(appI18nDefaultDir, defaultFile);
+
+        if (fs.existsSync(defaultFilePath)) {
+          const lang = defaultFile.replace(".json", "");
+
+          if (!translations[lang]) {
+            translations[lang] = {};
+          }
+
+          try {
+            const content = JSON.parse(
+              fs.readFileSync(defaultFilePath, "utf-8")
+            );
+
+            if (isDebugMode) {
+              console.log(`  ✓ app defaults (${lang})`);
+            }
+
+            // Ajouter ou surcharger les traductions personnalisées
+            Object.assign(translations[lang], content);
+          } catch (error) {
+            console.warn(`  ⚠️  Error reading ${defaultFilePath}:`, error);
+          }
+        }
+      }
+    }
+
     // Créer le dossier i18n s'il n'existe pas
     ensureDirectory(appI18nDir);
 
@@ -1824,6 +2571,81 @@ function extractModuleNameFromPath(filePath: string): string {
   return "unknown";
 }
 
+/**
+ * Génère la page d'accueil app/[lang]/page.tsx si un module définit path: "/"
+ */
+function generateHomePage(moduleConfigs: ModuleBuildConfig[]) {
+  // Chercher une page avec section: "public" et path: "/"
+  let homePageModule: ModuleBuildConfig | null = null;
+  let homePageConfig: ModulePageConfig | null = null;
+
+  for (const moduleConfig of moduleConfigs) {
+    const homePage = moduleConfig.pages.find(
+      (page) => page.section === "public" && page.path === "/"
+    );
+    if (homePage) {
+      homePageModule = moduleConfig;
+      homePageConfig = homePage;
+      break;
+    }
+  }
+
+  if (!homePageModule || !homePageConfig) {
+    if (isDebugMode) {
+      console.log("  ℹ️  No homepage (/) definition found in modules");
+    }
+    return;
+  }
+
+  // Générer la home dans le segment public: app/[lang]/(public)/page.tsx
+  const homePageDir = path.join(appDirectory, "[lang]", "(public)");
+  const homePagePath = path.join(homePageDir, "page.tsx");
+  ensureDirectory(homePageDir);
+
+  // Déterminer le chemin d'import
+  const importPath = homePageConfig.entryPoint
+    ? `${homePageModule.moduleName}/${homePageConfig.entryPoint}`
+    : homePageModule.moduleName;
+
+  // Éviter les collisions de nom (HomePage importé et wrapper exporté)
+  const importComponentName = homePageConfig.componentExport;
+  const wrapperComponentName = `${importComponentName}AppWrapper`;
+  const metadataImportAlias = homePageConfig.metadataExport
+    ? `${homePageConfig.metadataExport} as ${homePageConfig.metadataExport}Original`
+    : "";
+
+  const content = `// GENERATED BY LASTBRAIN MODULE BUILD
+// Homepage from ${homePageModule.moduleName}
+import { ${importComponentName} as ModuleHomePage${homePageConfig.metadataExport ? `, ${metadataImportAlias}` : ""} } from "${importPath}";
+
+import { LOCALE_CONFIG } from "../../../config/locales.generated";
+${
+  homePageConfig.metadataExport
+    ? `\nexport async function generateMetadata(props: any) {
+  return ${homePageConfig.metadataExport}Original({ ...props, localeConfig: LOCALE_CONFIG });
+}`
+    : ""
+}
+export default function ${wrapperComponentName}({
+  params,
+}: {
+  params: Promise<{ lang: string }>;
+}) {
+  return <ModuleHomePage params={params} localeConfig={LOCALE_CONFIG} />;
+}
+`;
+
+  fs.writeFileSync(homePagePath, content, "utf-8");
+
+  if (isDebugMode) {
+    console.log(
+      `  ✅ Generated homepage: ${homePagePath} (from ${homePageModule.moduleName})`
+    );
+  } else {
+    console.log(`🏠 Generated homepage from ${homePageModule.moduleName}`);
+  }
+}
+
 export async function runModuleBuild() {
   ensureDirectory(appDirectory);
 
@@ -1886,10 +2708,17 @@ export async function runModuleBuild() {
   dumpNavigation();
   generateMenuConfig(moduleConfigs);
   generateDocsPage(moduleConfigs);
-  generateAppAside();
-  generateLayouts();
+  // Note: AppAside, AppHeader, etc. sont maintenant générés dans components/ à la racine
+  // et non plus dupliqués dans app/components/
+  generateLayouts(moduleConfigs);
   copyModuleMigrations(moduleConfigs);
 
+  // Générer la page d'accueil "/" si un module la définit
+  if (isDebugMode) {
+    console.log("🏠 Checking for homepage (/) definition...");
+  }
+  generateHomePage(moduleConfigs);
+
   // Générer la configuration realtime
   if (isDebugMode) {
     console.log("🔄 Generating realtime configuration...");
@@ -1902,6 +2731,12 @@ export async function runModuleBuild() {
   }
   await generateUserTabsConfig(moduleConfigs);
 
+  // Générer la configuration et la page auth dashboard
+  if (isDebugMode) {
+    console.log("📊 Generating auth dashboard configuration...");
+  }
+  await generateAuthDashboard(moduleConfigs);
+
   // Générer la configuration des buckets storage
   if (isDebugMode) {
     console.log("🗄️  Generating storage buckets configuration...");
@@ -1920,12 +2755,37 @@ export async function runModuleBuild() {
   }
   await generateFooterConfig(moduleConfigs);
 
+  // Générer les routes sitemap (ancien système)
+  if (isDebugMode) {
+    console.log("🗺️  Generating sitemap routes (legacy)...");
+  }
+  //await generateSitemapRoutes(moduleConfigs);
+
+  // Générer les sitemaps basés sur manifests (nouveau système)
+  if (isDebugMode) {
+    console.log("🗺️  Generating manifest-based sitemaps...");
+  }
+  const availableLanguages = Object.keys(LOCALE_MAP);
+  await generateManifestBasedSitemaps(
+    appDirectory,
+    moduleConfigs,
+    availableLanguages,
+    projectRequire,
+    isDebugMode
+  );
+
   // Générer les fichiers i18n
   if (isDebugMode) {
     console.log("🌍 Building i18n files...");
   }
   await generateI18nFiles();
 
+  // Générer la configuration des locales
+  if (isDebugMode) {
+    console.log("🌐 Generating locale configuration...");
+  }
+  await generateLocaleConfig();
+
   // Message de succès final
   if (!isDebugMode) {
     console.log("\n✅ Module build completed successfully!");