@jhits/dashboard 0.0.5 → 0.0.7

package/package.json

@@ -1,46 +1,63 @@
 {
   "name": "@jhits/dashboard",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "A comprehensive dashboard system built to manage custom built websites - plugin based SaaS system.",
   "main": "./src/index.tsx",
   "types": "./src/index.tsx",
+  "browser": {
+    "./src/lib/mongodb.ts": false,
+    "./src/lib/auth.ts": false,
+    "./src/server.ts": false,
+    "./src/index.server.tsx": false,
+    "./src/api/masterRouter.ts": false,
+    "./src/api/pluginRouter.ts": false,
+    "mongodb": false,
+    "bcrypt": false,
+    "jsonwebtoken": false,
+    "server-only": false
+  },
   "exports": {
     ".": {
       "types": "./src/index.tsx",
+      "import": "./src/index.tsx",
       "default": "./src/index.tsx"
     },
+    "./lib/*": {
+      "types": "./src/lib/*.ts",
+      "default": "./src/lib/*.ts"
+    },
+    "./client": {
+      "types": "./src/index.client.tsx",
+      "import": "./src/index.client.tsx",
+      "default": "./src/index.client.tsx"
+    },
+    "./server": {
+      "types": "./src/index.server.tsx",
+      "import": "./src/index.server.tsx",
+      "default": "./src/index.server.tsx"
+    },
     "./config": {
       "types": "./src/config.ts",
       "default": "./src/config.ts"
     },
-    "./server": {
-      "types": "./src/server.ts",
-      "default": "./src/server.ts",
-      "node": "./src/server.ts"
-    },
     "./catch-all": {
       "types": "./src/app/[locale]/catch-all/page.tsx",
       "default": "./src/app/[locale]/catch-all/page.tsx"
     },
-    "./components/*": "./src/components/*",
-    "./lib/*": "./src/lib/*",
-    "./lib/auth": {
-      "types": "./src/lib/auth.ts",
-      "default": "./src/lib/auth.ts"
+    "./src/empty-loader.js": {
+      "default": "./src/empty-loader.js"
+    },
+    "./src/empty.js": {
+      "default": "./src/empty.js"
     }
   },
   "scripts": {
-    "lint": "eslint"
+    "lint": "eslint",
+    "type-check": "tsc --noEmit",
+    "type-check:all": "bash ../check-types.sh"
   },
   "dependencies": {
-    "@jhits/plugin-blog": "^0.0.1",
-    "@jhits/plugin-content": "^0.0.1",
-    "@jhits/plugin-dep": "^0.0.1",
-    "@jhits/plugin-images": "^0.0.1",
-    "@jhits/plugin-telemetry": "^0.0.1",
-    "@jhits/plugin-users": "^0.0.1",
-    "@jhits/plugin-website": "^0.0.1",
-    "@jhits/plugin-newsletter": "^0.0.1",
+    "@jhits/plugin-core": "^0.0.1",
     "@types/jsonwebtoken": "^9.0.10",
     "bcrypt": "^6.0.0",
     "framer-motion": "^12.23.26",
@@ -54,7 +71,14 @@
   "peerDependencies": {
     "next": "^14.0.0 || ^15.0.0 || ^16.0.0",
     "react": "^18.0.0 || ^19.0.0",
-    "react-dom": "^18.0.0 || ^19.0.0"
+    "react-dom": "^18.0.0 || ^19.0.0",
+    "@jhits/plugin-blog": "*",
+    "@jhits/plugin-content": "*",
+    "@jhits/plugin-images": "*",
+    "@jhits/plugin-users": "*",
+    "@jhits/plugin-website": "*",
+    "@jhits/plugin-newsletter": "*",
+    "@jhits/plugin-telemetry": "*"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4",
@@ -71,7 +95,12 @@
     "typescript": "^5"
   },
   "files": [
-    "src",
+    "src/**/*.{ts,tsx,js,jsx,css,json,svg}",
+    "!src/**/*.md",
+    "!src/**/README.md",
+    "!README.md",
+    "package.json",
+    "empty.js",
     "next.config.ts",
     "postcss.config.mjs",
     "tailwind.config.ts"

package/src/api/pluginRouter.ts

@@ -119,11 +119,19 @@ export async function handlePluginApi(
             getDb: config.mongoClient ? createGetDb(config.mongoClient) : undefined,
             // Add getUserId - uses NextAuth session token (works with or without jwtSecret)
             getUserId: (req: NextRequest) => getUserIdFromRequest(req, config.jwtSecret),
-            // authOptions is already in config, but ensure it's passed through for plugin-users
+            // Explicitly ensure authOptions is passed through for plugin-users
+            authOptions: config.authOptions,
             // emailConfig and baseUrl are already in config, but ensure they're passed through for plugin-newsletter
             emailConfig: config.emailConfig,
             baseUrl: config.baseUrl,
         };
+        
+        // Debug logging for plugin-users to verify authOptions are present
+        if (normalizedId === 'plugin-users' && !adaptedConfig.authOptions) {
+            console.warn('[PluginRouter] WARNING: authOptions missing for plugin-users');
+            console.warn('[PluginRouter] Config keys:', Object.keys(config));
+            console.warn('[PluginRouter] authOptions in config:', !!config.authOptions);
+        }
 
         return await handler(req, path, adaptedConfig);
 

package/src/config.ts

@@ -1,26 +1,18 @@
 // packages/jhits-dashboard/src/config.ts
 import type { NextConfig } from "next";
-import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs";
-import { join } from "path";
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 
 /**
  * Automatically creates a catch-all route that handles dashboard routes
- * This runs at build time when withJhitsDashboard() is called
- * No dashboard folder needed - routes are handled via catch-all at [locale] level
  */
 async function ensureDashboardRoutes() {
     try {
-        // Find the host app directory (where next.config.ts is)
         let appDir = process.cwd();
-        const possiblePaths = [
-            appDir,
-            join(appDir, '..'),
-            join(appDir, '..', '..'),
-        ];
+        const possiblePaths = [appDir, join(appDir, '..'), join(appDir, '..', '..')];
 
         for (const basePath of possiblePaths) {
-            const configPath = join(basePath, 'next.config.ts');
-            if (existsSync(configPath)) {
+            if (existsSync(join(basePath, 'next.config.ts'))) {
                 appDir = basePath;
                 break;
             }
@@ -30,17 +22,11 @@ async function ensureDashboardRoutes() {
         const catchAllDir = join(localeDir, '[...path]');
         const catchAllPath = join(catchAllDir, 'page.tsx');
 
-        // Check if catch-all already exists
+        // If it exists, try to inject the dashboard handler
         if (existsSync(catchAllPath)) {
-            // Read existing file and check if it already handles dashboard
-            const fs = await import('fs');
-            const existingContent = fs.readFileSync(catchAllPath, 'utf8');
-            if (existingContent.includes('@jhits/dashboard') || existingContent.includes('DashboardRouter')) {
-                // Already set up, skip
-                return;
-            }
-            // If it exists but doesn't handle dashboard, we need to modify it
-            // Read the file and prepend dashboard handling
+            const existingContent = readFileSync(catchAllPath, 'utf8');
+            if (existingContent.includes('@jhits/dashboard') || existingContent.includes('DashboardRouter')) return;
+
             const dashboardHandler = `
     // Dashboard route handling (auto-added by @jhits/dashboard)
     if (path.length > 0 && path[0] === 'dashboard') {
@@ -53,178 +39,163 @@ async function ensureDashboardRoutes() {
         );
     }
 `;
-            // Insert dashboard handling at the beginning of the function body
             const modifiedContent = existingContent.replace(
                 /(export default async function \w+\([^)]+\) \{[\s\S]*?const resolvedParams = await props\.params;[\s\S]*?const path = resolvedParams\.path \|\| \[\];)/,
                 `$1${dashboardHandler}`
             );
-
-            if (modifiedContent !== existingContent) {
-                fs.writeFileSync(catchAllPath, modifiedContent);
-            } else {
-                // If replacement didn't work, append at a safe location
-                const safeInsertPoint = existingContent.indexOf('const path = resolvedParams.path');
-                if (safeInsertPoint > -1) {
-                    const before = existingContent.substring(0, safeInsertPoint);
-                    const after = existingContent.substring(safeInsertPoint);
-                    const newContent = before + dashboardHandler.trim() + '\n    ' + after;
-                    fs.writeFileSync(catchAllPath, newContent);
-                }
-            }
+            writeFileSync(catchAllPath, modifiedContent);
             return;
         }
 
-        // Create new catch-all route that handles dashboard routes
+        // Create new catch-all if none exists
         mkdirSync(catchAllDir, { recursive: true });
-        writeFileSync(catchAllPath, `// Auto-generated by @jhits/dashboard - do not edit manually
-export { default } from '@jhits/dashboard/catch-all';
-`);
-    } catch (error) {
-        // Silently fail - routes might already exist or be manually created
+        writeFileSync(catchAllPath, `// Auto-generated by @jhits/dashboard - do not edit manually\nexport { default } from '@jhits/dashboard/catch-all';\n`);
+    } catch (e) {
+        console.warn('[@jhits/dashboard] Could not auto-generate dashboard routes:', e);
     }
 }
 
 /**
- * Dynamically find all @jhits/* packages from package.json
- * Reads dependencies and devDependencies to build transpilePackages list
- * 
- * This function finds the app's package.json by looking for next.config.ts
- * in the same directory, ensuring we read from the correct location in monorepos
+ * Finds all @jhits/* packages to ensure they are transpiled
  */
 function findJhitsPackages(): string[] {
     try {
-        // Find the app directory (where next.config.ts is located)
         const appDir = process.cwd();
-        const possiblePaths = [
-            appDir,
-            join(appDir, '..'),
-            join(appDir, '..', '..'),
-        ];
-
-        let packageJsonPath: string | null = null;
-
-        for (const basePath of possiblePaths) {
-            const configPath = join(basePath, 'next.config.ts');
-            const pkgPath = join(basePath, 'package.json');
-            if (existsSync(configPath) && existsSync(pkgPath)) {
-                packageJsonPath = pkgPath;
-                break;
-            }
-        }
-
-        // Fallback to process.cwd() if we can't find next.config.ts
-        if (!packageJsonPath) {
-            packageJsonPath = join(process.cwd(), 'package.json');
-        }
-
-        if (!existsSync(packageJsonPath)) {
-            // Fallback to wildcard if package.json not found
-            return ['@jhits'];
-        }
-
-        // Use readFileSync instead of require() to avoid module resolution issues
-        const packageJsonContent = readFileSync(packageJsonPath, 'utf-8');
-        const packageJson = JSON.parse(packageJsonContent);
-
-        const allDeps = {
-            ...(packageJson.dependencies || {}),
-            ...(packageJson.devDependencies || {}),
-        };
+        const packageJsonPath = join(appDir, 'package.json');
+        if (!existsSync(packageJsonPath)) return ['@jhits'];
 
-        // Filter for packages starting with @jhits/
-        const jhitsPackages = Object.keys(allDeps).filter(
-            (pkg) => pkg.startsWith('@jhits/')
-        );
-
-        // Always include the base @jhits pattern for any other packages
-        return jhitsPackages.length > 0 ? jhitsPackages : ['@jhits'];
-    } catch (error) {
-        // Fallback to wildcard on any error
-        console.warn('[withJhitsDashboard] Could not read package.json, using @jhits wildcard');
-        return ['@jhits'];
-    }
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        const allDeps = { ...(packageJson.dependencies || {}), ...(packageJson.devDependencies || {}) };
+        return Object.keys(allDeps).filter(pkg => pkg.startsWith('@jhits/'));
+    } catch { return ['@jhits']; }
 }
 
-/**
- * JHITS Dashboard Plugin Configuration
- * 
- * Usage:
- *   import { withJhitsDashboard } from '@jhits/dashboard/config';
- *   export default withJhitsDashboard(nextConfig);
- * 
- * This automatically sets up all dashboard routes - no manual setup needed!
- */
 export function withJhitsDashboard(nextConfig: NextConfig = {}): NextConfig {
-    // Auto-create dashboard routes at build time
-    // NOTE: User management routes are now handled by plugin-users via the unified plugin router
-    // No need to auto-generate /api/users routes anymore
-    if (typeof window === 'undefined') {
-        try {
-            ensureDashboardRoutes();
-            // ensureUserManagementRoutes(); // Disabled - routes are handled by plugin-users via plugin router
-        } catch (error) {
-            // Ignore errors - routes might already exist
-        }
+    // Only run file system modifications on the server during initialization
+    if (typeof window === 'undefined' && process.env.NEXT_PHASE !== 'phase-production-build') {
+        ensureDashboardRoutes().catch(() => { });
     }
 
+    const emptyFile = "@jhits/dashboard/src/empty.js";
+    // Use package-relative path for the loader - Turbopack can resolve this
+    // This works both in development (monorepo) and when installed as a package
+    const emptyLoaderPath = "@jhits/dashboard/src/empty-loader.js";
+
     return {
         ...nextConfig,
 
-        // 1. AUTO-TRANSPILE: Dynamically find all @jhits/* packages from package.json
-        // This ensures Turbopack knows exactly which workspace folders to link
         transpilePackages: [
             ...(nextConfig.transpilePackages || []),
             ...findJhitsPackages()
         ],
 
+        turbopack: {
+            ...nextConfig.turbopack,
+            rules: {
+                ...nextConfig.turbopack?.rules,
+                // Handle .md files by treating them as empty JavaScript modules
+                // This prevents "Unknown module type" errors for README.md files
+                // According to Next.js docs: pattern should be *.md with as: *.js
+                // Using our custom empty-loader to return empty module
+                // Loaders can be strings (package names or file paths)
+                '*.md': {
+                    loaders: [emptyLoaderPath],
+                    as: '*.js',
+                },
+                '*.mdx': {
+                    loaders: [emptyLoaderPath],
+                    as: '*.js',
+                },
+            },
+            resolveAlias: {
+                ...nextConfig.turbopack?.resolveAlias,
+                // CRITICAL: We only alias specific toxic libraries.
+                // We DO NOT alias 'fs', 'path', or 'child_process' here because
+                // it breaks the Next.js internal build tools (WASM/SWC).
+                "mongodb": emptyFile,
+                "bcrypt": emptyFile,
+                "nodemailer": emptyFile,
+                // "dns": emptyFile,
+                "server-only": emptyFile,
+                // Shield the auth logic from the client
+                "@jhits/dashboard/lib/auth": emptyFile,
+                // "wasi_snapshot_preview1": emptyFile,
+                // Alias specific .md files to empty file (Turbopack doesn't support wildcards in resolveAlias)
+                // Add aliases for known README.md locations in @jhits packages
+                "README.md": emptyFile,
+                "@jhits/dashboard/README.md": emptyFile,
+                "@jhits/plugin-blog/README.md": emptyFile,
+                "@jhits/plugin-content/README.md": emptyFile,
+                "@jhits/plugin-images/README.md": emptyFile,
+                "@jhits/plugin-users/README.md": emptyFile,
+                "@jhits/plugin-website/README.md": emptyFile,
+                "@jhits/plugin-newsletter/README.md": emptyFile,
+                "@jhits/plugin-telemetry/README.md": emptyFile,
+                "@jhits/plugin-dep/README.md": emptyFile,
+                "@jhits/plugin-core/README.md": emptyFile,
+            }
+        },
+
         experimental: {
             ...nextConfig.experimental,
-            // 2. MONOREPO RESOLUTION: This is the secret sauce. 
-            // It allows Next.js to follow symlinks in the pnpm workspace 
-            // even if they aren't explicitly listed.
             externalDir: true,
         },
 
-        // Exclude server-only third-party packages from client bundles
-        // Note: @jhits/* packages should NOT be here - they're in transpilePackages instead
-        // Adding them here would conflict with transpilePackages in Turbopack
         serverExternalPackages: [
             ...(nextConfig.serverExternalPackages || []),
-            'mongodb',
-            'bcrypt',
-            'bcryptjs',
-            'jsonwebtoken',
-            'nodemailer'
+            'mongodb', 'bcrypt', 'bcryptjs', 'jsonwebtoken', 'nodemailer'
         ],
 
         webpack: (config, { isServer }) => {
-            // Ensure Node.js modules are not bundled for client
             if (!isServer) {
+                // Webpack is safer for building "fallbacks" than Turbopack's global alias
                 config.resolve.fallback = {
                     ...config.resolve.fallback,
                     fs: false,
-                    path: false,
-                    'fs/promises': false,
-                    child_process: false,
                     net: false,
                     tls: false,
-                    crypto: false,
+                    child_process: false,
+                    os: false,
                 };
-
-                // Prevent server-only plugins from being bundled into client
-                // plugin-dep is server-only and should never be imported by client code
-                config.externals = config.externals || [];
-                if (Array.isArray(config.externals)) {
-                    config.externals.push('@jhits/plugin-dep');
-                } else if (typeof config.externals === 'object') {
-                    config.externals['@jhits/plugin-dep'] = '@jhits/plugin-dep';
-                }
             }
+            
+            // Ignore .md files (README.md, etc.) from node_modules
+            // This prevents Next.js from trying to process them as modules
+            try {
+                const webpack = require('webpack');
+                config.plugins = config.plugins || [];
+                // Ignore all .md and .mdx files completely
+                config.plugins.push(
+                    new webpack.IgnorePlugin({
+                        resourceRegExp: /\.md$/,
+                    }),
+                    new webpack.IgnorePlugin({
+                        resourceRegExp: /\.mdx$/,
+                    })
+                );
+            } catch {
+                // webpack might not be available in some contexts
+            }
+            
+            // Add resolve alias for .md files to prevent module resolution errors
+            config.resolve.alias = {
+                ...config.resolve.alias,
+                'README.md': false,
+            };
+            
+            // Add a rule to handle .md files as empty modules if they somehow get imported
+            // This is a fallback in case IgnorePlugin doesn't catch everything
+            config.module = config.module || {};
+            config.module.rules = config.module.rules || [];
+            // Insert at the beginning to catch .md files before other rules
+            config.module.rules.unshift({
+                test: /\.mdx?$/,
+                use: {
+                    loader: require.resolve('./empty-loader.js'),
+                },
+            });
+            
             return config;
         },
-
-        // Routes are automatically created and managed by the plugin
-        // The dashboard folder is completely transparent - you never need to touch it
-        // Just use withJhitsDashboard() and everything works!
     };
 }

package/src/empty-loader.js

@@ -0,0 +1,4 @@
+// Simple loader that returns an empty module for .md files
+module.exports = function(source) {
+    return 'module.exports = {};';
+};

package/src/empty.js

@@ -0,0 +1,2 @@
+// packages/jhits-dashboard/empty.js
+module.exports = {};

package/src/index.client.tsx

@@ -0,0 +1,16 @@
+// Main export file for the dashboard plugin - CLIENT-SAFE ONLY
+// This file should NEVER import or export server-only code
+
+'use client';
+
+// Client-safe components only
+export { PluginRegistry } from './lib/plugin-registry';
+export { PluginNotFound } from './components/PluginNotFound';
+export { WebsiteProvider, useWebsite } from './lib/website-context';
+export type { WebsiteInfo } from './lib/website-context';
+export { Providers, AuthGuard } from './components/Providers';
+
+// Client components
+export { default as Sidebar } from './components/dashboard/Sidebar';
+export { default as Topbar } from './components/dashboard/Topbar';
+

package/src/index.server.tsx

@@ -0,0 +1,63 @@
+// Server-only exports for the dashboard plugin
+// This file contains all server-side functionality
+
+import 'server-only';
+
+// Router components - server-only
+import DashboardLayout from './app/[locale]/dashboard/layout';
+import DashboardHome from './app/[locale]/dashboard/page';
+import DashboardPreferences from './app/[locale]/dashboard/preferences/page';
+import DashboardProfile from './app/[locale]/dashboard/profile/page';
+import DashboardPluginRoute from './app/[locale]/dashboard/[...pluginRoute]/page';
+
+export async function DashboardRouter({
+    path,
+    params
+}: {
+    path: string[];
+    params: Promise<{ locale: string }>;
+}) {
+    const resolvedParams = await params;
+    const locale = resolvedParams.locale;
+
+    // Get the actual route (first segment of path)
+    const route = path.length === 0 ? 'home' : path[0];
+
+    // Handle different dashboard routes
+    switch (route) {
+        case 'preferences':
+            return <DashboardPreferences />;
+        case 'profile':
+            return <DashboardProfile />;
+        case 'home':
+        case '':
+            return <DashboardHome />;
+        default:
+            // This is a plugin route - pass the full path as pluginRoute
+            return <DashboardPluginRoute params={Promise.resolve({
+                locale,
+                pluginRoute: path
+            })} />;
+    }
+}
+
+// Layout wrapper
+export function DashboardRouterLayout({ children }: { children: React.ReactNode }) {
+    return <DashboardLayout>{children}</DashboardLayout>;
+}
+
+// Server-only components
+export { default as DashboardCatchAll } from './components/DashboardCatchAll';
+
+// Server-only config and utilities
+export { withJhitsDashboard } from './config';
+export { getDashboardMessages } from './i18n/translations';
+export { PLATFORM_MODULES } from './lib/modules-config';
+
+// Server-only lib exports (for advanced usage)
+export { authOptions } from './lib/auth';
+export { default as clientPromise } from './lib/mongodb';
+
+// API router exports
+export { handlePluginApi, type PluginRouterConfig } from './api/pluginRouter';
+export { handleDashboardApi, createNextRequestFromRequest } from './api/masterRouter';

package/src/index.tsx

@@ -1,69 +1,16 @@
 // Main export file for the dashboard plugin
-// This exports all the dashboard components and pages that can be used by host apps
-
-// Router components - inlined to avoid module resolution issues
-import DashboardLayout from './app/[locale]/dashboard/layout';
-import DashboardHome from './app/[locale]/dashboard/page';
-import DashboardPreferences from './app/[locale]/dashboard/preferences/page';
-import DashboardProfile from './app/[locale]/dashboard/profile/page';
-import DashboardPluginRoute from './app/[locale]/dashboard/[...pluginRoute]/page';
-
-export async function DashboardRouter({ 
-    path, 
-    params 
-}: { 
-    path: string[];
-    params: Promise<{ locale: string }>;
-}) {
-    const resolvedParams = await params;
-    const locale = resolvedParams.locale;
-    
-    // Get the actual route (first segment of path)
-    const route = path.length === 0 ? 'home' : path[0];
-    
-    // Handle different dashboard routes
-    switch (route) {
-        case 'preferences':
-            return <DashboardPreferences />;
-        case 'profile':
-            return <DashboardProfile />;
-        case 'home':
-        case '':
-            return <DashboardHome />;
-        default:
-            // This is a plugin route - pass the full path as pluginRoute
-            return <DashboardPluginRoute params={Promise.resolve({ 
-                locale, 
-                pluginRoute: path 
-            })} />;
-    }
-}
-
-// Layout wrapper
-export function DashboardRouterLayout({ children }: { children: React.ReactNode }) {
-    return <DashboardLayout>{children}</DashboardLayout>;
-}
-
-// Components (for advanced usage)
-export { default as Sidebar } from './components/dashboard/Sidebar';
-export { default as Topbar } from './components/dashboard/Topbar';
-export { PluginNotFound } from './components/PluginNotFound';
-export { Providers, AuthGuard } from './components/Providers';
-
-// Plugin system
-export { PluginRegistry } from './lib/plugin-registry';
-export { PLATFORM_MODULES } from './lib/modules-config';
-
-// Config
-export { withJhitsDashboard } from './config';
-
-// Translations
-export { getDashboardMessages } from './i18n/translations';
-
-// Catch-all route handler (for client app integration)
-export { default as DashboardCatchAll } from './components/DashboardCatchAll';
-
-// Website context (for accessing website info in dashboard components)
-export { WebsiteProvider, useWebsite } from './lib/website-context';
-export type { WebsiteInfo } from './lib/website-context';
+// Re-exports client-safe code by default
+// For server-only code, import from '@jhits/dashboard/server'
+
+// Re-export client-safe code
+export * from './index.client';
+
+// Note: Server-only exports are available via '@jhits/dashboard/server'
+// This includes:
+// - DashboardRouter, DashboardRouterLayout
+// - DashboardCatchAll
+// - withJhitsDashboard
+// - getDashboardMessages
+// - PLATFORM_MODULES
+// - authOptions, clientPromise
 

package/src/lib/modules-config.ts

@@ -1,5 +1,3 @@
-import 'server-only';
-
 // src/lib/modules-config.ts
 import { BarChart3, Newspaper, Globe, Users, Mail, type LucideIcon } from 'lucide-react';
 

package/src/lib/plugin-registry.tsx

@@ -11,23 +11,23 @@ const library = pluginData as PluginManifest[];
 // Cache for resolved components to avoid recreating them
 const componentCache = new Map<string, React.ComponentType<PluginProps>>();
 
-// Dynamic plugin loader factory
-// This creates a loader function that dynamically imports plugins based on the JSON configuration
-// Plugins are loaded from @jhits/{repoName} where repoName comes from plugins.json
-function createDynamicPluginLoader(repoName: string): () => Promise<React.ComponentType<PluginProps>> {
-    return async () => {
-        try {
-            // Dynamically import the plugin package
-            // The package name follows the pattern: @jhits/{repoName}
-            const pluginModule = await import(`@jhits/${repoName}`);
-            // Return the default export or Index export
-            return pluginModule.default || pluginModule.Index;
-        } catch (error) {
-            console.error(`Failed to load plugin "${repoName}":`, error);
-            throw new Error(`Plugin "${repoName}" could not be loaded. Make sure it's installed and the package name matches @jhits/${repoName}`);
-        }
-    };
-}
+/**
+ * EXPLICIT LOADER MAP
+ * This is the fix for the "Module Not Found" (tls, net, fs) errors.
+ * By explicitly defining the imports, Turbopack/Webpack knows exactly 
+ * which files to bundle and can safely ignore the /server.ts files.
+ */
+const pluginLoaders: Record<string, () => Promise<any>> = {
+    'plugin-blog': () => import('@jhits/plugin-blog'),
+    'plugin-users': () => import('@jhits/plugin-users'),
+    'plugin-dep': () => import('@jhits/plugin-dep'),
+    'plugin-telemetry': () => import('@jhits/plugin-telemetry'),
+    'plugin-website': () => import('@jhits/plugin-website'),
+    'plugin-images': () => import('@jhits/plugin-images'),
+    'plugin-content': () => import('@jhits/plugin-content'),
+    'plugin-newsletter': () => import('@jhits/plugin-newsletter'),
+    // Add any other plugins that appear in your plugins.json here
+};
 
 export const PluginRegistry = {
     // Returns the static data from JSON
@@ -35,37 +35,58 @@ export const PluginRegistry = {
         return library.find(p => p.routePrefix === prefix);
     },
 
-    // Resolves the actual React Component with caching
-    // Dynamically loads plugins based on the JSON configuration
-    // No hardcoded plugin list - everything comes from plugins.json
+    /**
+     * Resolves the actual React Component with caching
+     * Uses the explicit loader map to ensure clean bundling
+     */
     resolveComponent: (repoName: string) => {
-        // Check cache first
+        // 1. Check cache first
         if (componentCache.has(repoName)) {
             return componentCache.get(repoName)!;
         }
 
-        // Verify the plugin exists in the JSON configuration
+        // 2. Verify the plugin exists in the JSON configuration
         const pluginManifest = library.find(p => p.repo === repoName);
         if (!pluginManifest) {
-            throw new Error(
-                `Plugin "${repoName}" not found in plugins.json. ` +
-                `Available plugins: ${library.map(p => `${p.repo} (${p.id})`).join(', ')}`
-            );
+            throw new Error(`Plugin "${repoName}" not found in plugins.json.`);
         }
 
         if (!pluginManifest.enabled) {
             throw new Error(`Plugin "${repoName}" is disabled in plugins.json`);
         }
 
-        // Create dynamic loader for this plugin
-        const loader = createDynamicPluginLoader(repoName);
+        // 3. Get the explicit loader
+        const loader = pluginLoaders[repoName];
+
+        if (!loader) {
+            console.error(`[PluginRegistry] No loader found for "${repoName}". Add it to the pluginLoaders map.`);
+            // Fallback component so the whole app doesn't crash
+            return () => (
+                <div className="p-10 border-2 border-dashed border-red-500 text-red-500">
+                    Configuration Error: <b>{repoName}</b> is not registered in the loader map.
+                </div>
+            );
+        }
 
-        // Create and cache the component using dynamic import
+        // 4. Create and cache the component using dynamic import
         const Component = dynamic<PluginProps>(
-            loader,
+            async () => {
+                try {
+                    const pluginModule = await loader();
+                    // Supports both 'export default' and 'export const Index'
+                    return pluginModule.default || pluginModule.Index;
+                } catch (error) {
+                    console.error(`Failed to load plugin "${repoName}":`, error);
+                    throw error;
+                }
+            },
             {
-                loading: () => <div className="p-10 animate-pulse font-black uppercase">Mounting_Module...</div>,
-                ssr: false
+                loading: () => (
+                    <div className="p-10 animate-pulse font-black uppercase text-zinc-500">
+                        Mounting_{repoName.replace('-', '_')}...
+                    </div>
+                ),
+                ssr: false // Prevents server-side Node.js errors during hydration
             }
         );
 

package/src/api/README.md

@@ -1,72 +0,0 @@
-# Dashboard API Master Router
-
-Centralized API routing system for all dashboard plugin endpoints.
-
-## Overview
-
-The master router automatically routes API requests to the appropriate plugin handler based on the URL path prefix. This eliminates the need for the client app to know about individual plugin endpoints.
-
-## Architecture
-
-```
-Client App
-  └── /api/dashboard/[...path]/route.ts (catch-all)
-       └── handleDashboardApi() (master router)
-            ├── /telemetry → @jhits/plugin-telemetry/api/route
-            ├── /blog → @jhits/plugin-blog/api/route (TODO)
-            └── /users → @jhits/plugin-users/api/route (TODO)
-```
-
-## Usage
-
-### In Client App
-
-Create a catch-all route at `src/app/api/dashboard/[...path]/route.ts`:
-
-```typescript
-import { NextRequest } from 'next/server';
-import { handleDashboardApi } from '@jhits/dashboard/server';
-
-export async function POST(
-    req: NextRequest,
-    { params }: { params: Promise<{ path: string[] }> }
-) {
-    const { path } = await params;
-    return handleDashboardApi(req, path);
-}
-
-// Add GET, PUT, DELETE, PATCH as needed
-```
-
-### Adding New Plugin Handlers
-
-1. Create your plugin handler in `@jhits/plugin-{name}/api/route.ts`:
-   ```typescript
-   import { NextRequest, NextResponse } from 'next/server';
-   
-   export async function POST(req: NextRequest): Promise<NextResponse> {
-       // Your handler logic
-   }
-   ```
-
-2. Add routing logic in `masterRouter.ts`:
-   ```typescript
-   if (pluginId === 'your-plugin') {
-       const { POST: yourPluginPOST } = await import('@jhits/plugin-your-plugin/api/route');
-       return await yourPluginPOST(req);
-   }
-   ```
-
-## Endpoints
-
-- `POST /api/dashboard/telemetry` - Telemetry logging
-- `POST /api/dashboard/blog` - Blog API (TODO)
-- `POST /api/dashboard/users` - Users API (TODO)
-
-## Benefits
-
-1. **Centralized Routing**: All plugin APIs go through one entry point
-2. **Easy Plugin Addition**: Add new plugins without modifying client app
-3. **Type Safety**: Full TypeScript support
-4. **Server-Only**: Handlers are only imported on the server side
-