@qwickapps/server 1.1.9 → 1.3.0

package/README.md

@@ -61,6 +61,8 @@ For production deployments, use `createGateway` to run a gateway that:
 1. Serves the control panel UI (always responsive, even if the API crashes)
 2. Proxies API requests to an internal service
 3. Handles graceful error responses when the internal service is down
+4. Supports maintenance mode with customizable status pages
+5. Shows service unavailable pages when mounted apps are unreachable
 
 ```typescript
 import { createGateway, createHealthPlugin } from '@qwickapps/server';
@@ -115,6 +117,68 @@ Internet → Gateway (3101, public) → API Service (3100, internal)
 
 The gateway is always responsive even if the internal API service crashes, allowing you to view diagnostics and error information.
 
+### Mounted Apps with Maintenance Mode
+
+Mount frontend apps or proxy services with full maintenance and fallback support:
+
+```typescript
+const gateway = createGateway({
+  // ... base config
+  mountedApps: [
+    {
+      path: '/app',
+      name: 'Main App',
+      type: 'proxy',
+      target: 'http://localhost:4000',
+      maintenance: {
+        enabled: false,  // Toggle to enable maintenance mode
+        title: 'Scheduled Maintenance',
+        message: 'We are upgrading our systems.',
+        expectedBackAt: '2 hours',  // or ISO date, or "soon"
+        contactUrl: 'https://status.example.com',
+        bypassPaths: ['/app/health', '/app/api/status'],
+      },
+      fallback: {
+        title: 'Service Unavailable',
+        message: 'The application is temporarily unavailable.',
+        showRetry: true,
+        autoRefresh: 30,  // seconds
+      },
+    },
+    {
+      path: '/docs',
+      name: 'Documentation',
+      type: 'static',
+      staticPath: './docs-dist',
+    },
+  ],
+});
+```
+
+### Maintenance and Fallback Configuration
+
+**MaintenanceConfig** - Shown when maintenance mode is enabled:
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `enabled` | `boolean` | Enable/disable maintenance mode |
+| `title` | `string` | Page title (default: "Under Maintenance") |
+| `message` | `string` | Custom message to display |
+| `expectedBackAt` | `string` | ETA: ISO date, relative time ("2 hours"), or "soon" |
+| `contactUrl` | `string` | Link to status page or contact |
+| `bypassPaths` | `string[]` | Paths that bypass maintenance (e.g., health checks) |
+
+**FallbackConfig** - Shown when the proxied service is unreachable:
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `title` | `string` | Page title (default: "Service Unavailable") |
+| `message` | `string` | Custom message to display |
+| `showRetry` | `boolean` | Show retry button (default: true) |
+| `autoRefresh` | `number` | Auto-refresh countdown in seconds (default: 30) |
+
+Both pages feature modern, responsive designs with automatic dark mode support.
+
 ## Configuration
 
 ### ControlPanelConfig
@@ -130,6 +194,7 @@ The gateway is always responsive even if the internal API service crashes, allow
 | `cors` | `object` | No | CORS origins configuration |
 | `links` | `array` | No | Quick links for the dashboard |
 | `skipBodyParserPaths` | `string[]` | No | Paths to skip body parsing (for proxy) |
+| `logoUrl` | `string` | No | Custom logo URL for the landing page |
 
 ### Route Guards
 
@@ -297,6 +362,259 @@ createLogsPlugin({
 });
 ```
 
+#### PostgreSQL Plugin
+
+Provides connection pooling, transactions, and health checks for PostgreSQL databases.
+
+```typescript
+import { createPostgresPlugin, getPostgres } from '@qwickapps/server';
+
+// Register the plugin
+createPostgresPlugin({
+  connectionString: process.env.DATABASE_URL,
+  // Or individual options:
+  // host: 'localhost',
+  // port: 5432,
+  // database: 'mydb',
+  // user: 'postgres',
+  // password: 'secret',
+  maxConnections: 20,
+  healthCheckInterval: 30000,
+});
+
+// Use in your code
+const pg = getPostgres();
+const result = await pg.query('SELECT * FROM users WHERE id = $1', [userId]);
+
+// With transactions
+await pg.withTransaction(async (client) => {
+  await client.query('INSERT INTO orders ...');
+  await client.query('UPDATE inventory ...');
+});
+```
+
+**Exports:**
+- `createPostgresPlugin(config)` - Create and register the plugin
+- `getPostgres(name?)` - Get a PostgreSQL instance (throws if not registered)
+- `hasPostgres(name?)` - Check if an instance is registered
+- `PostgresInstance` - TypeScript type for the instance
+
+#### Cache Plugin
+
+Redis-based caching with key prefixing, TTL support, and pattern operations.
+
+```typescript
+import { createCachePlugin, getCache } from '@qwickapps/server';
+
+// Register the plugin
+createCachePlugin({
+  url: process.env.REDIS_URL,
+  // Or individual options:
+  // host: 'localhost',
+  // port: 6379,
+  // password: 'secret',
+  keyPrefix: 'myapp:',
+  defaultTTL: 3600, // 1 hour default
+  healthCheckInterval: 30000,
+});
+
+// Use in your code
+const cache = getCache();
+
+// Basic operations
+await cache.set('user:123', userData, 600); // TTL in seconds
+const user = await cache.get('user:123');
+await cache.delete('user:123');
+
+// Pattern operations
+const keys = await cache.keys('user:*');
+await cache.deletePattern('session:*');
+
+// Stats and maintenance
+const stats = await cache.getStats();
+await cache.flush(); // Clear all keys with prefix
+```
+
+**Exports:**
+- `createCachePlugin(config)` - Create and register the plugin
+- `getCache(name?)` - Get a cache instance (throws if not registered)
+- `hasCache(name?)` - Check if an instance is registered
+- `CacheInstance` - TypeScript type for the instance
+
+#### Auth Plugin
+
+Pluggable authentication with support for multiple providers via the adapter pattern.
+
+```typescript
+import { createAuthPlugin, auth0Adapter, basicAdapter } from '@qwickapps/server';
+
+// Auth0 with RBAC and domain restrictions
+createAuthPlugin({
+  adapter: auth0Adapter({
+    domain: process.env.AUTH0_DOMAIN!,
+    clientId: process.env.AUTH0_CLIENT_ID!,
+    clientSecret: process.env.AUTH0_CLIENT_SECRET!,
+    baseUrl: 'https://myapp.example.com',
+    secret: process.env.SESSION_SECRET!,
+    audience: process.env.AUTH0_AUDIENCE,    // For API access tokens
+    allowedRoles: ['admin', 'support'],       // RBAC filtering
+    allowedDomains: ['@company.com'],         // Domain whitelist
+    exposeAccessToken: true,                  // For downstream API calls
+  }),
+  excludePaths: ['/health', '/api/public'],
+});
+
+// Basic auth fallback
+createAuthPlugin({
+  adapter: basicAdapter({
+    username: 'admin',
+    password: process.env.ADMIN_PASSWORD!,
+  }),
+});
+```
+
+**Available Adapters:**
+- `auth0Adapter` - Auth0 OIDC (requires `express-openid-connect`)
+- `supabaseAdapter` - Supabase JWT validation
+- `basicAdapter` - HTTP Basic authentication
+
+**Helper Functions:**
+```typescript
+import { isAuthenticated, getAuthenticatedUser, getAccessToken } from '@qwickapps/server';
+
+// In your route handlers
+if (isAuthenticated(req)) {
+  const user = getAuthenticatedUser(req);
+  // { id, email, name, picture, emailVerified, roles }
+
+  const accessToken = getAccessToken(req);
+  // Use for downstream API calls
+}
+```
+
+**Middleware Helpers:**
+```typescript
+import { requireAuth, requireRoles, requireAnyRole } from '@qwickapps/server';
+
+// Require authentication
+app.get('/admin', requireAuth(), (req, res) => { ... });
+
+// Require specific roles (all required)
+app.get('/admin/users', requireRoles('admin', 'user-manager'), (req, res) => { ... });
+
+// Require any of the roles
+app.get('/dashboard', requireAnyRole('admin', 'editor', 'viewer'), (req, res) => { ... });
+```
+
+#### Users Plugin
+
+Storage-agnostic user management with ban support.
+
+```typescript
+import { createUsersPlugin, postgresUserStore, getPostgres } from '@qwickapps/server';
+import { Pool } from 'pg';
+
+// Create with PostgreSQL storage
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+
+createUsersPlugin({
+  store: postgresUserStore({
+    pool,
+    usersTable: 'users',
+    bansTable: 'user_bans',
+    autoCreateTables: true,
+  }),
+  bans: {
+    enabled: true,
+    supportTemporary: true, // Enable expiring bans
+    onBan: async (user, ban) => {
+      // Notify external systems, revoke sessions, etc.
+      console.log(`User ${user.email} banned: ${ban.reason}`);
+    },
+    onUnban: async (user) => {
+      console.log(`User ${user.email} unbanned`);
+    },
+  },
+  api: {
+    prefix: '/api/users',
+    crud: true,    // GET/POST/PUT/DELETE /api/users
+    search: true,  // GET /api/users?q=...
+    bans: true,    // Ban management endpoints
+  },
+});
+```
+
+**REST API Endpoints:**
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/api/users` | GET | List/search users |
+| `/api/users` | POST | Create user |
+| `/api/users/:id` | GET | Get user by ID |
+| `/api/users/:id` | PUT | Update user |
+| `/api/users/:id` | DELETE | Delete user |
+| `/api/users/bans` | GET | List active bans |
+| `/api/users/:id/ban` | GET | Get user's ban status |
+| `/api/users/:id/ban` | POST | Ban user |
+| `/api/users/:id/ban` | DELETE | Unban user |
+| `/api/users/:id/bans` | GET | Get user's ban history |
+
+**Helper Functions:**
+```typescript
+import { getUserById, getUserByEmail, isUserBanned, findOrCreateUser } from '@qwickapps/server';
+
+// Get user
+const user = await getUserById('user-123');
+const userByEmail = await getUserByEmail('test@example.com');
+
+// Check ban status
+const banned = await isUserBanned('user-123');
+
+// Find or create from auth provider
+const user = await findOrCreateUser({
+  email: 'user@example.com',
+  name: 'Test User',
+  external_id: 'auth0|12345',
+  provider: 'auth0',
+});
+```
+
+**Email Ban Support (for auth-only scenarios):**
+
+For cases where you don't store users locally but need to ban by email:
+
+```typescript
+import { isEmailBanned, getEmailBan, banEmail, unbanEmail } from '@qwickapps/server';
+
+// Check if email is banned
+const banned = await isEmailBanned('user@example.com');
+
+// Get ban details
+const ban = await getEmailBan('user@example.com');
+
+// Ban an email
+await banEmail({
+  email: 'user@example.com',
+  reason: 'Spam activity',
+  banned_by: 'admin@company.com',
+  duration: 86400, // 24 hours (optional, null = permanent)
+});
+
+// Unban an email
+await unbanEmail({
+  email: 'user@example.com',
+  unbanned_by: 'admin@company.com',
+  note: 'Cleared after review',
+});
+```
+
+**Email Ban API Endpoints:**
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/api/users/email-bans` | GET | List active email bans |
+| `/api/users/email-bans/:email` | GET | Check email ban status |
+| `/api/users/email-bans` | POST | Ban an email |
+| `/api/users/email-bans/:email` | DELETE | Unban an email |
+
 ### Creating Custom Plugins
 
 ```typescript

package/dist/core/control-panel.d.ts

@@ -6,10 +6,15 @@
  * Copyright (c) 2025 QwickApps.com. All rights reserved.
  */
 import { type LoggingConfig } from './logging.js';
-import type { ControlPanelConfig, ControlPanelPlugin, ControlPanelInstance, Logger } from './types.js';
+import type { ControlPanelConfig, ControlPanelInstance, Logger } from './types.js';
+import { type Plugin, type PluginConfig } from './plugin-registry.js';
 export interface CreateControlPanelOptions {
     config: ControlPanelConfig;
-    plugins?: ControlPanelPlugin[];
+    /** Plugins to start with the control panel */
+    plugins?: Array<{
+        plugin: Plugin;
+        config?: PluginConfig;
+    }>;
     logger?: Logger;
     /** Logging configuration */
     logging?: LoggingConfig;

package/dist/core/control-panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"control-panel.d.ts","sourceRoot":"","sources":["../../src/core/control-panel.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAUH,OAAO,EAA4C,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAE5F,OAAO,KAAK,EACV,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EAIpB,MAAM,EACP,MAAM,YAAY,CAAC;AAWpB,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,OAAO,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4BAA4B;IAC5B,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,oBAAoB,CA2Q3F"}
+{"version":3,"file":"control-panel.d.ts","sourceRoot":"","sources":["../../src/core/control-panel.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAUH,OAAO,EAA4C,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAE5F,OAAO,KAAK,EACV,kBAAkB,EAClB,oBAAoB,EAGpB,MAAM,EACP,MAAM,YAAY,CAAC;AACpB,OAAO,EAEL,KAAK,MAAM,EACX,KAAK,YAAY,EAElB,MAAM,sBAAsB,CAAC;AAuB9B,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,8CAA8C;IAC9C,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,YAAY,CAAA;KAAE,CAAC,CAAC;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4BAA4B;IAC5B,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,oBAAoB,CAgT3F"}

package/dist/core/control-panel.js

@@ -9,12 +9,13 @@ import express from 'express';
 import helmet from 'helmet';
 import cors from 'cors';
 import compression from 'compression';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { HealthManager } from './health-manager.js';
 import { initializeLogging, getControlPanelLogger } from './logging.js';
 import { createRouteGuard } from './guards.js';
+import { createPluginRegistry, } from './plugin-registry.js';
 // Get the package root directory for serving UI assets
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -23,6 +24,18 @@ const packageRoot = __dirname.includes('/src/')
     ? join(__dirname, '..', '..')
     : join(__dirname, '..', '..');
 const uiDistPath = join(packageRoot, 'dist-ui');
+// Read @qwickapps/server package version
+let frameworkVersion = '1.0.0';
+try {
+    const packageJsonPath = join(packageRoot, 'package.json');
+    if (existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        frameworkVersion = packageJson.version || '1.0.0';
+    }
+}
+catch {
+    // Keep default version if reading fails
+}
 /**
  * Create a control panel instance
  */
@@ -38,9 +51,10 @@ export function createControlPanel(options) {
     const app = express();
     const router = express.Router();
     const healthManager = new HealthManager(logger);
-    const registeredPlugins = [];
     let server = null;
     const startTime = Date.now();
+    // Initialize the new plugin registry
+    const pluginRegistry = createPluginRegistry(app, router, logger, healthManager, getControlPanelLogger);
     // Security middleware
     app.use(helmet({
         contentSecurityPolicy: false, // Allow inline scripts for simple UI
@@ -65,13 +79,14 @@ export function createControlPanel(options) {
         app.use(express.json());
     }
     app.use(compression());
-    // Apply route guard if configured
+    // Get mount path (defaults to /cpanel)
+    const mountPath = config.mountPath || '/cpanel';
+    // Apply route guard if configured - only to the control panel mount path
     if (config.guard && config.guard.type !== 'none') {
         const guardMiddleware = createRouteGuard(config.guard);
-        app.use(guardMiddleware);
+        // Only protect the control panel path, not the root or other paths
+        app.use(mountPath, guardMiddleware);
     }
-    // Get mount path (defaults to /cpanel)
-    const mountPath = config.mountPath || '/cpanel';
     const apiBasePath = mountPath === '/' ? '/api' : `${mountPath}/api`;
     // Request logging
     app.use((req, _res, next) => {
@@ -101,6 +116,8 @@ export function createControlPanel(options) {
     router.get('/info', (_req, res) => {
         res.json({
             product: config.productName,
+            logoName: config.logoName || config.productName,
+            logoIconUrl: config.logoIconUrl,
             version: config.version || 'unknown',
             uptime: Date.now() - startTime,
             links: config.links || [],
@@ -114,6 +131,28 @@ export function createControlPanel(options) {
         const report = getDiagnostics();
         res.json(report);
     });
+    /**
+     * GET /api/ui-contributions - UI contributions from all plugins
+     *
+     * Returns menu items, pages, and widgets registered by plugins.
+     * Used by the React UI to build dynamic navigation and pages.
+     */
+    router.get('/ui-contributions', (_req, res) => {
+        res.json({
+            menuItems: pluginRegistry.getMenuItems(),
+            pages: pluginRegistry.getPages(),
+            widgets: pluginRegistry.getWidgets(),
+            plugins: pluginRegistry.listPlugins(),
+        });
+    });
+    /**
+     * GET /api/plugins - List all registered plugins
+     */
+    router.get('/plugins', (_req, res) => {
+        res.json({
+            plugins: pluginRegistry.listPlugins(),
+        });
+    });
     /**
      * Serve dashboard UI at the configured mount path
      *
@@ -129,20 +168,53 @@ export function createControlPanel(options) {
         logger.debug(`Dashboard config: mountPath=${mountPath}, effectiveUiPath=${effectiveUiPath}, hasRichUI=${hasRichUI}, useRichUI=${useRichUI}`);
         if (useRichUI) {
             logger.debug(`Serving React UI from ${effectiveUiPath}`);
+            // Read index.html template
+            const indexHtmlPath = join(effectiveUiPath, 'index.html');
+            const indexHtmlTemplate = readFileSync(indexHtmlPath, 'utf-8');
+            /**
+             * Get index.html with the base path injected.
+             *
+             * The server injects the base path as window.__APP_BASE_PATH__ so the React app
+             * can read it at runtime without complex detection logic. This is the standard
+             * pattern used by frameworks like Next.js (__NEXT_DATA__).
+             *
+             * When served behind a gateway proxy, use X-Forwarded-Prefix to determine
+             * the public path for assets and the React Router basename.
+             */
+            const getIndexHtml = (req) => {
+                // Determine the effective public path:
+                // - If X-Forwarded-Prefix header is set (proxied), use that
+                // - Otherwise, use the configured mountPath
+                const forwardedPrefix = req.get('X-Forwarded-Prefix');
+                const effectivePath = forwardedPrefix || mountPath;
+                const normalizedPath = effectivePath === '/' ? '' : effectivePath;
+                // Inject base path as global variable before other scripts
+                const basePathScript = `<script>window.__APP_BASE_PATH__="${normalizedPath}";</script>`;
+                let html = indexHtmlTemplate.replace('<head>', `<head>\n    ${basePathScript}`);
+                // Rewrite asset paths if mounted at a subpath
+                if (normalizedPath) {
+                    html = html.replace(/src="\/assets\//g, `src="${normalizedPath}/assets/`);
+                    html = html.replace(/href="\/assets\//g, `href="${normalizedPath}/assets/`);
+                }
+                return html;
+            };
             // Serve static assets from dist-ui at the mount path
-            app.use(mountPath, express.static(effectiveUiPath));
+            // Disable index: false to prevent serving index.html automatically
+            // We handle index.html separately with rewritten asset paths
+            app.use(mountPath, express.static(effectiveUiPath, { index: false }));
             // SPA fallback - serve index.html for all non-API routes under the mount path
-            app.get(`${mountPath}/*`, (req, res, next) => {
+            const spaFallbackPath = mountPath === '/' ? '/*' : `${mountPath}/*`;
+            app.get(spaFallbackPath, (req, res, next) => {
                 // Skip API routes
                 if (req.path.startsWith(apiBasePath)) {
                     return next();
                 }
-                res.sendFile(join(effectiveUiPath, 'index.html'));
+                res.type('html').send(getIndexHtml(req));
             });
             // Also serve the mount path root
             if (mountPath !== '/') {
-                app.get(mountPath, (_req, res) => {
-                    res.sendFile(join(effectiveUiPath, 'index.html'));
+                app.get(mountPath, (req, res) => {
+                    res.type('html').send(getIndexHtml(req));
                 });
             }
         }
@@ -155,43 +227,9 @@ export function createControlPanel(options) {
             });
         }
     }
-    // Plugin context factory - creates context with plugin-specific logger
-    const createPluginContext = (pluginName) => ({
-        config,
-        app,
-        router,
-        logger: getControlPanelLogger(pluginName),
-        registerHealthCheck: (check) => healthManager.register(check),
-    });
-    // Register plugin
-    const registerPlugin = async (plugin) => {
-        logger.debug(`Registering plugin: ${plugin.name}`);
-        // Register routes
-        if (plugin.routes) {
-            for (const route of plugin.routes) {
-                switch (route.method) {
-                    case 'get':
-                        router.get(route.path, route.handler);
-                        break;
-                    case 'post':
-                        router.post(route.path, route.handler);
-                        break;
-                    case 'put':
-                        router.put(route.path, route.handler);
-                        break;
-                    case 'delete':
-                        router.delete(route.path, route.handler);
-                        break;
-                }
-                logger.debug(`Registered route: ${route.method.toUpperCase()} ${route.path}`);
-            }
-        }
-        // Initialize plugin with plugin-specific logger
-        if (plugin.onInit) {
-            await plugin.onInit(createPluginContext(plugin.name));
-        }
-        registeredPlugins.push(plugin);
-        logger.debug(`Plugin registered: ${plugin.name}`);
+    // Start a plugin with the registry
+    const startPlugin = async (plugin, pluginConfig = {}) => {
+        return pluginRegistry.startPlugin(plugin, pluginConfig);
     };
     // Get diagnostics report
     const getDiagnostics = () => {
@@ -200,6 +238,7 @@ export function createControlPanel(options) {
             timestamp: new Date().toISOString(),
             product: config.productName,
             version: config.version,
+            frameworkVersion,
             uptime: Date.now() - startTime,
             health: healthManager.getResults(),
             system: {
@@ -219,32 +258,31 @@ export function createControlPanel(options) {
     };
     // Start server
     const start = async () => {
-        // Register initial plugins
-        for (const plugin of plugins) {
-            await registerPlugin(plugin);
+        // Start initial plugins via registry
+        for (const { plugin, config: pluginConfig } of plugins) {
+            const success = await pluginRegistry.startPlugin(plugin, pluginConfig || {});
+            if (!success) {
+                logger.error(`Failed to start plugin: ${plugin.id}`);
+            }
         }
         return new Promise((resolve) => {
             server = app.listen(config.port, () => {
-                logger.info(`Control panel listening on port ${config.port}`);
+                logger.debug(`Control panel listening on port ${config.port}`);
                 resolve();
             });
         });
     };
     // Stop server
     const stop = async () => {
-        // Shutdown plugins
-        for (const plugin of registeredPlugins) {
-            if (plugin.onShutdown) {
-                await plugin.onShutdown();
-            }
-        }
+        // Stop all plugins via registry
+        await pluginRegistry.stopAllPlugins();
         // Shutdown health manager
         healthManager.shutdown();
         // Close server
         if (server) {
             return new Promise((resolve) => {
                 server.close(() => {
-                    logger.info('Control panel stopped');
+                    logger.debug('Control panel stopped');
                     resolve();
                 });
             });
@@ -254,9 +292,10 @@ export function createControlPanel(options) {
         app,
         start,
         stop,
-        registerPlugin,
+        startPlugin,
         getHealthStatus: () => healthManager.getResults(),
         getDiagnostics,
+        getPluginRegistry: () => pluginRegistry,
     };
 }
 /**