@majkapp/plugin-kit 1.0.0

package/dist/plugin-kit.js

@@ -0,0 +1,695 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definePlugin = definePlugin;
+const http_1 = __importDefault(require("http"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Build-time errors with clear, actionable messages
+ */
+class PluginBuildError extends Error {
+    constructor(message, suggestion, context) {
+        super(message);
+        this.suggestion = suggestion;
+        this.context = context;
+        this.name = 'PluginBuildError';
+    }
+    toString() {
+        let msg = `\n❌ Plugin Build Failed: ${this.message}`;
+        if (this.suggestion) {
+            msg += `\n💡 Suggestion: ${this.suggestion}`;
+        }
+        if (this.context) {
+            msg += `\n📋 Context: ${JSON.stringify(this.context, null, 2)}`;
+        }
+        return msg;
+    }
+}
+/**
+ * Runtime errors with clear context
+ */
+class PluginRuntimeError extends Error {
+    constructor(message, operation, context) {
+        super(message);
+        this.operation = operation;
+        this.context = context;
+        this.name = 'PluginRuntimeError';
+    }
+}
+/**
+ * Validation helper for descriptions
+ */
+function validateDescription(desc, name) {
+    if (!desc)
+        return;
+    const trimmed = desc.trim();
+    if (!trimmed.endsWith('.')) {
+        throw new PluginBuildError(`Description for "${name}" must end with a period`, `Add a period at the end: "${desc}."`);
+    }
+    const sentences = trimmed.split(/[.!?]/).map(s => s.trim()).filter(Boolean);
+    if (sentences.length < 2 || sentences.length > 3) {
+        throw new PluginBuildError(`Description for "${name}" must be 2-3 sentences, found ${sentences.length} sentences`, `Rewrite the description to have 2-3 clear sentences. Current: "${desc}"`, { sentences });
+    }
+}
+/**
+ * Path parameter regex builder
+ */
+function pathToRegex(p) {
+    const keys = [];
+    const pattern = p
+        .replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1')
+        .replace(/\/:([A-Za-z0-9_]+)/g, (_m, k) => {
+        keys.push(k);
+        return '/([^/]+)';
+    });
+    return { regex: new RegExp(`^${pattern}$`), keys };
+}
+/**
+ * CORS headers
+ */
+function corsHeaders(extra = {}) {
+    return {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+        ...extra
+    };
+}
+/**
+ * Read request body
+ */
+async function readBody(req) {
+    if (req.method === 'GET' || req.method === 'HEAD' || req.method === 'OPTIONS') {
+        return undefined;
+    }
+    return new Promise((resolve) => {
+        let data = '';
+        req.on('data', (chunk) => (data += chunk.toString()));
+        req.on('end', () => {
+            if (!data) {
+                resolve(undefined);
+                return;
+            }
+            try {
+                resolve(JSON.parse(data));
+            }
+            catch {
+                resolve(data);
+            }
+        });
+    });
+}
+/**
+ * Create response wrapper
+ */
+function makeResponse(res) {
+    return {
+        status(code) {
+            res.statusCode = code;
+            return this;
+        },
+        setHeader(key, value) {
+            res.setHeader(key, value);
+        },
+        json(data) {
+            if (!res.headersSent) {
+                res.writeHead(res.statusCode || 200, corsHeaders({ 'Content-Type': 'application/json' }));
+            }
+            res.end(JSON.stringify(data));
+        },
+        send(data) {
+            if (!res.headersSent) {
+                res.writeHead(res.statusCode || 200, corsHeaders());
+            }
+            res.end(data);
+        }
+    };
+}
+/**
+ * Content type helper
+ */
+function getContentType(filePath) {
+    const ext = path_1.default.extname(filePath).toLowerCase();
+    const types = {
+        '.html': 'text/html',
+        '.js': 'application/javascript',
+        '.css': 'text/css',
+        '.json': 'application/json',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.svg': 'image/svg+xml',
+        '.woff': 'font/woff',
+        '.woff2': 'font/woff2',
+        '.ttf': 'font/ttf'
+    };
+    return types[ext] || 'application/octet-stream';
+}
+/**
+ * Serve React SPA
+ */
+function serveSpa(ui, req, res, ctx) {
+    const url = new URL(req.url, 'http://localhost');
+    const rel = url.pathname.substring(ui.base.length) || '/';
+    const distPath = path_1.default.join(process.cwd(), ui.appDir);
+    let filePath = path_1.default.join(distPath, rel);
+    if (filePath.endsWith('/')) {
+        filePath = path_1.default.join(filePath, 'index.html');
+    }
+    // Security: prevent path traversal
+    const normalizedPath = path_1.default.resolve(filePath);
+    if (!normalizedPath.startsWith(path_1.default.resolve(distPath))) {
+        res.writeHead(403, corsHeaders({ 'Content-Type': 'text/plain' }));
+        res.end('Forbidden: Path traversal detected');
+        ctx.logger.warn(`Path traversal attempt blocked: ${rel}`);
+        return;
+    }
+    const exists = fs_1.default.existsSync(filePath) && fs_1.default.statSync(filePath).isFile();
+    const targetFile = exists ? filePath : path_1.default.join(distPath, 'index.html');
+    if (!fs_1.default.existsSync(targetFile)) {
+        res.writeHead(404, corsHeaders({ 'Content-Type': 'text/plain' }));
+        res.end('Not found');
+        return;
+    }
+    let content = fs_1.default.readFileSync(targetFile);
+    // Inject base URL for React apps
+    if (path_1.default.basename(targetFile) === 'index.html') {
+        const html = content.toString('utf-8');
+        const inject = `<script>` +
+            `window.__MAJK_BASE_URL__=${JSON.stringify(ctx.http.baseUrl)};` +
+            `window.__MAJK_IFRAME_BASE__=${JSON.stringify(ui.base)};` +
+            `window.__MAJK_PLUGIN_ID__=${JSON.stringify(ctx.pluginId)};` +
+            `</script>`;
+        const injected = html.replace('</head>', `${inject}</head>`);
+        content = Buffer.from(injected, 'utf-8');
+    }
+    res.writeHead(200, corsHeaders({ 'Content-Type': getContentType(targetFile) }));
+    res.end(content);
+}
+/**
+ * Main plugin class built by the fluent API
+ */
+class BuiltPlugin {
+    constructor(id, name, version, capabilities, tools, apiRoutes, uiConfig, reactScreens, htmlScreens, wizard, onReadyFn, healthCheckFn) {
+        this.capabilities = capabilities;
+        this.tools = tools;
+        this.apiRoutes = apiRoutes;
+        this.uiConfig = uiConfig;
+        this.reactScreens = reactScreens;
+        this.htmlScreens = htmlScreens;
+        this.wizard = wizard;
+        this.onReadyFn = onReadyFn;
+        this.healthCheckFn = healthCheckFn;
+        this.cleanups = [];
+        this.router = [];
+        this.id = id;
+        this.name = name;
+        this.version = version;
+    }
+    getCapabilities() {
+        return {
+            apiVersion: 'majk.capabilities/v1',
+            capabilities: this.capabilities
+        };
+    }
+    /**
+     * Config wizard shouldShow hook - called by ConfigWizardCapabilityHandler
+     */
+    async shouldShowConfigWizard() {
+        if (this.wizard?.shouldShow) {
+            return await this.wizard.shouldShow(this.context);
+        }
+        return false;
+    }
+    async createTool(toolName) {
+        const handler = this.tools.get(toolName);
+        if (!handler) {
+            throw new PluginRuntimeError(`Tool "${toolName}" not found`, 'createTool', { toolName, availableTools: Array.from(this.tools.keys()) });
+        }
+        return {
+            handler: (input) => {
+                const toolContext = {
+                    majk: this.context.majk,
+                    storage: this.context.storage,
+                    logger: this.context.logger
+                };
+                return Promise.resolve(handler(input, toolContext));
+            }
+        };
+    }
+    async onLoad(context) {
+        this.context = context;
+        context.logger.info('═══════════════════════════════════════════════════════');
+        context.logger.info(`🚀 Loading Plugin: ${this.name} (${this.id}) v${this.version}`);
+        context.logger.info(`📍 Plugin Root: ${context.pluginRoot}`);
+        context.logger.info(`🌐 HTTP Port: ${context.http.port}`);
+        context.logger.info(`🔗 Base URL: ${context.http.baseUrl}`);
+        context.logger.info('═══════════════════════════════════════════════════════');
+        try {
+            await this.startServer();
+            // Register API routes
+            for (const route of this.apiRoutes) {
+                const { regex, keys } = pathToRegex(route.path);
+                this.router.push({
+                    method: route.method,
+                    regex,
+                    keys,
+                    name: route.name,
+                    description: route.description,
+                    handler: route.handler
+                });
+                context.logger.info(`📝 Registered route: ${route.method} ${route.path} - ${route.name}`);
+            }
+            // Call onReady hook
+            if (this.onReadyFn) {
+                context.logger.info('⚙️  Calling onReady hook...');
+                await this.onReadyFn(this.context, (fn) => this.cleanups.push(fn));
+                context.logger.info('✅ onReady hook completed');
+            }
+            context.logger.info(`✅ Plugin "${this.name}" loaded successfully`);
+        }
+        catch (error) {
+            context.logger.error(`❌ Failed to load plugin "${this.name}": ${error.message}`);
+            if (error.stack) {
+                context.logger.error(error.stack);
+            }
+            throw error;
+        }
+    }
+    async onUnload() {
+        this.context.logger.info(`🛑 Unloading plugin: ${this.name}`);
+        // Run cleanup functions
+        for (const cleanup of this.cleanups.splice(0)) {
+            try {
+                cleanup();
+            }
+            catch (error) {
+                this.context.logger.error(`Error during cleanup: ${error.message}`);
+            }
+        }
+        // Stop HTTP server
+        if (this.server) {
+            await new Promise((resolve) => {
+                this.server.close(() => {
+                    this.context.logger.info('✅ HTTP server stopped');
+                    resolve();
+                });
+            });
+        }
+        this.context.logger.info(`✅ Plugin "${this.name}" unloaded`);
+    }
+    async isHealthy() {
+        if (this.healthCheckFn) {
+            try {
+                const result = await this.healthCheckFn({
+                    majk: this.context.majk,
+                    storage: this.context.storage,
+                    logger: this.context.logger
+                });
+                return { ...result, errors: [], warnings: [] };
+            }
+            catch (error) {
+                return {
+                    healthy: false,
+                    errors: [`Health check failed: ${error.message}`]
+                };
+            }
+        }
+        return { healthy: true };
+    }
+    async startServer() {
+        const { port } = this.context.http;
+        this.server = http_1.default.createServer(async (req, res) => {
+            try {
+                // CORS preflight
+                if (req.method === 'OPTIONS') {
+                    res.writeHead(204, corsHeaders());
+                    res.end();
+                    return;
+                }
+                // Health check
+                if (req.method === 'GET' && req.url === '/health') {
+                    const health = await this.isHealthy();
+                    res.writeHead(200, corsHeaders({ 'Content-Type': 'application/json' }));
+                    res.end(JSON.stringify({ ...health, plugin: this.name, version: this.version }));
+                    return;
+                }
+                // HTML screens virtual route
+                if (req.method === 'GET' && req.url?.startsWith('/__html/')) {
+                    const id = decodeURIComponent(req.url.substring('/__html/'.length)).split('?')[0];
+                    const screen = this.htmlScreens.find(s => s.id === id);
+                    if (!screen) {
+                        res.writeHead(404, corsHeaders({ 'Content-Type': 'text/plain' }));
+                        res.end('HTML screen not found');
+                        return;
+                    }
+                    res.writeHead(200, corsHeaders({ 'Content-Type': 'text/html; charset=utf-8' }));
+                    if ('html' in screen) {
+                        res.end(screen.html);
+                    }
+                    else {
+                        const filePath = path_1.default.join(process.cwd(), screen.htmlFile);
+                        // Security check
+                        const normalized = path_1.default.resolve(filePath);
+                        if (!normalized.startsWith(process.cwd())) {
+                            res.writeHead(403, corsHeaders({ 'Content-Type': 'text/plain' }));
+                            res.end('Forbidden');
+                            this.context.logger.warn(`Path traversal attempt: ${screen.htmlFile}`);
+                            return;
+                        }
+                        try {
+                            res.end(fs_1.default.readFileSync(filePath));
+                        }
+                        catch (error) {
+                            this.context.logger.error(`Failed to read HTML file: ${error.message}`);
+                            res.writeHead(500, corsHeaders({ 'Content-Type': 'text/html' }));
+                            res.end('<!doctype html><html><body><h1>Error loading screen</h1></body></html>');
+                        }
+                    }
+                    return;
+                }
+                // React SPA
+                if (req.method === 'GET' && this.uiConfig && req.url?.startsWith(this.uiConfig.base)) {
+                    serveSpa(this.uiConfig, req, res, this.context);
+                    return;
+                }
+                // API routes
+                if (req.url?.startsWith('/api/')) {
+                    const url = new URL(req.url, `http://localhost:${port}`);
+                    const pathname = url.pathname;
+                    const method = req.method;
+                    const route = this.router.find(r => r.method === method && r.regex.test(pathname));
+                    if (!route) {
+                        res.writeHead(404, corsHeaders({ 'Content-Type': 'application/json' }));
+                        res.end(JSON.stringify({
+                            error: 'Route not found',
+                            path: pathname,
+                            method,
+                            hint: `Available routes: ${this.router.map(r => `${r.method} ${r.name}`).join(', ')}`
+                        }));
+                        return;
+                    }
+                    const body = await readBody(req);
+                    const match = pathname.match(route.regex);
+                    const params = {};
+                    route.keys.forEach((key, i) => {
+                        params[key] = decodeURIComponent(match[i + 1]);
+                    });
+                    const request = {
+                        method,
+                        url: req.url,
+                        pathname,
+                        query: url.searchParams,
+                        params,
+                        body,
+                        headers: req.headers
+                    };
+                    const response = makeResponse(res);
+                    const routeContext = {
+                        majk: this.context.majk,
+                        storage: this.context.storage,
+                        logger: this.context.logger,
+                        http: this.context.http
+                    };
+                    try {
+                        this.context.logger.debug(`📥 ${method} ${pathname}`, { params, body });
+                        const result = await route.handler(request, response, routeContext);
+                        if (!res.headersSent) {
+                            res.writeHead(200, corsHeaders({ 'Content-Type': 'application/json' }));
+                            res.end(JSON.stringify(result ?? { success: true }));
+                        }
+                        this.context.logger.debug(`📤 ${method} ${pathname} - Success`);
+                    }
+                    catch (error) {
+                        this.context.logger.error(`❌ ${method} ${pathname} - Error: ${error.message}`);
+                        if (error.stack) {
+                            this.context.logger.error(error.stack);
+                        }
+                        if (!res.headersSent) {
+                            res.writeHead(500, corsHeaders({ 'Content-Type': 'application/json' }));
+                            res.end(JSON.stringify({
+                                error: error.message || 'Internal server error',
+                                route: route.name,
+                                path: pathname
+                            }));
+                        }
+                    }
+                    return;
+                }
+                // 404
+                res.writeHead(404, corsHeaders({ 'Content-Type': 'application/json' }));
+                res.end(JSON.stringify({ error: 'Not found', path: req.url }));
+            }
+            catch (error) {
+                this.context.logger.error(`Unhandled server error: ${error.message}`);
+                if (!res.headersSent) {
+                    res.writeHead(500, corsHeaders({ 'Content-Type': 'text/plain' }));
+                    res.end('Internal server error');
+                }
+            }
+        });
+        await new Promise((resolve) => {
+            this.server.listen(port, () => {
+                this.context.logger.info(`✅ HTTP server listening on port ${port}`);
+                resolve();
+            });
+        });
+    }
+}
+/**
+ * Group tools by scope
+ */
+function groupByScope(tools) {
+    const map = new Map();
+    for (const { scope, spec } of tools) {
+        const arr = map.get(scope) || [];
+        arr.push(spec);
+        map.set(scope, arr);
+    }
+    return Array.from(map, ([scope, tools]) => ({ scope, tools }));
+}
+/**
+ * Create a plugin with fluent builder API
+ */
+function definePlugin(id, name, version) {
+    const _capabilities = [];
+    const _tools = new Map();
+    const _toolSpecs = [];
+    const _apiRoutes = [];
+    const _reactScreens = [];
+    const _htmlScreens = [];
+    const _topbars = [];
+    const _entities = [];
+    let _ui = { appDir: 'ui/dist', base: '/', history: 'browser' };
+    let _uiConfigured = false;
+    let _wizard = null;
+    let _settings = null;
+    let _onReady = null;
+    let _healthCheck = null;
+    const builder = {
+        topbar(route, opts) {
+            _topbars.push({
+                id: opts?.id || `${id}-topbar-${_topbars.length + 1}`,
+                name: opts?.name || name,
+                icon: opts?.icon,
+                route
+            });
+            return this;
+        },
+        ui(config) {
+            _uiConfigured = true;
+            if (config?.appDir)
+                _ui.appDir = config.appDir;
+            if (config?.base)
+                _ui.base = config.base;
+            if (config?.history)
+                _ui.history = config.history;
+            return this;
+        },
+        screenReact(screen) {
+            validateDescription(screen.description, `React screen "${screen.name}"`);
+            if (!screen.route.startsWith(`/plugin-screens/${id}/`)) {
+                throw new PluginBuildError(`React screen route must start with "/plugin-screens/${id}/"`, `Change route from "${screen.route}" to "/plugin-screens/${id}/your-route"`, { screen: screen.id, route: screen.route });
+            }
+            const iframeUrl = `http://localhost:{port}${_ui.base}${screen.reactPath}`;
+            _reactScreens.push(screen);
+            _capabilities.push({
+                type: 'screen',
+                id: screen.id,
+                path: screen.route,
+                iframeUrl
+            });
+            return this;
+        },
+        screenHtml(screen) {
+            validateDescription(screen.description, `HTML screen "${screen.name}"`);
+            if (!screen.route.startsWith(`/plugin-screens/${id}/`)) {
+                throw new PluginBuildError(`HTML screen route must start with "/plugin-screens/${id}/"`, `Change route from "${screen.route}" to "/plugin-screens/${id}/your-route"`, { screen: screen.id, route: screen.route });
+            }
+            const iframeUrl = `http://localhost:{port}/__html/${encodeURIComponent(screen.id)}`;
+            _htmlScreens.push(screen);
+            _capabilities.push({
+                type: 'screen',
+                id: screen.id,
+                path: screen.route,
+                iframeUrl
+            });
+            return this;
+        },
+        apiRoute(route) {
+            validateDescription(route.description, `API route "${route.name}"`);
+            if (!route.path.startsWith('/api/')) {
+                throw new PluginBuildError(`API route path must start with "/api/"`, `Change path from "${route.path}" to "/api/your-endpoint"`, { route: route.name });
+            }
+            _apiRoutes.push(route);
+            return this;
+        },
+        tool(scope, spec, handler) {
+            validateDescription(spec.description, `Tool "${spec.name}"`);
+            if (_tools.has(spec.name)) {
+                throw new PluginBuildError(`Duplicate tool name: "${spec.name}"`, 'Tool names must be unique within a plugin', { tool: spec.name, existingTools: Array.from(_tools.keys()) });
+            }
+            _tools.set(spec.name, handler);
+            _toolSpecs.push({ scope, spec });
+            return this;
+        },
+        entity(entityType, entities) {
+            _entities.push({ entityType, entities });
+            return this;
+        },
+        configWizard(def) {
+            if (_wizard) {
+                throw new PluginBuildError('Config wizard already defined', 'You can only have one config wizard per plugin');
+            }
+            validateDescription(def.description, 'Config wizard');
+            _wizard = def;
+            return this;
+        },
+        settings(def) {
+            if (_settings) {
+                throw new PluginBuildError('Settings already defined', 'You can only have one settings screen per plugin');
+            }
+            validateDescription(def.description, 'Settings');
+            _settings = def;
+            return this;
+        },
+        onReady(fn) {
+            _onReady = fn;
+            return this;
+        },
+        health(fn) {
+            _healthCheck = fn;
+            return this;
+        },
+        build() {
+            // ========== Build-Time Validation ==========
+            // Validate React UI setup
+            if (_reactScreens.length > 0 && !_uiConfigured) {
+                throw new PluginBuildError('UI not configured but React screens were added', 'Call .ui() before adding React screens', { reactScreens: _reactScreens.map(s => s.id) });
+            }
+            // Validate React dist exists
+            if (_reactScreens.length > 0) {
+                const indexPath = path_1.default.join(process.cwd(), _ui.appDir, 'index.html');
+                if (!fs_1.default.existsSync(indexPath)) {
+                    throw new PluginBuildError(`React app not built: ${indexPath} does not exist`, `Run "npm run build" in your UI directory to build the React app`, { appDir: _ui.appDir, indexPath });
+                }
+            }
+            // Validate HTML screen files
+            for (const screen of _htmlScreens) {
+                if ('htmlFile' in screen) {
+                    const filePath = path_1.default.join(process.cwd(), screen.htmlFile);
+                    if (!fs_1.default.existsSync(filePath)) {
+                        throw new PluginBuildError(`HTML screen file not found: ${screen.htmlFile}`, `Create the HTML file at ${filePath} or fix the path`, { screen: screen.id, file: screen.htmlFile });
+                    }
+                }
+            }
+            // Validate screen routes
+            const screenRoutes = new Set();
+            for (const screen of [..._reactScreens, ..._htmlScreens]) {
+                if (screenRoutes.has(screen.route)) {
+                    throw new PluginBuildError(`Duplicate screen route: ${screen.route}`, 'Each screen must have a unique route', { route: screen.route, screens: [..._reactScreens, ..._htmlScreens].map(s => ({ id: s.id, route: s.route })) });
+                }
+                screenRoutes.add(screen.route);
+            }
+            // Validate topbar routes
+            for (const topbar of _topbars) {
+                if (!screenRoutes.has(topbar.route)) {
+                    throw new PluginBuildError(`Topbar route "${topbar.route}" doesn't match any screen`, 'Topbar routes must point to declared screens', { topbarId: topbar.id, route: topbar.route, availableScreens: Array.from(screenRoutes) });
+                }
+            }
+            // Validate API route uniqueness
+            const apiSignatures = new Set();
+            for (const route of _apiRoutes) {
+                const signature = `${route.method} ${route.path}`;
+                if (apiSignatures.has(signature)) {
+                    throw new PluginBuildError(`Duplicate API route: ${signature}`, 'Each API route (method + path) must be unique', { route: signature, allRoutes: Array.from(apiSignatures) });
+                }
+                apiSignatures.add(signature);
+            }
+            // ========== Build Capabilities ==========
+            // Add topbars
+            for (const topbar of _topbars) {
+                _capabilities.push({
+                    type: 'topbar',
+                    id: topbar.id,
+                    name: topbar.name,
+                    icon: topbar.icon,
+                    route: topbar.route
+                });
+            }
+            // Add tools (grouped by scope)
+            const toolGroups = groupByScope(_toolSpecs);
+            for (const group of toolGroups) {
+                _capabilities.push({
+                    type: 'tool',
+                    scope: group.scope,
+                    tools: group.tools
+                });
+            }
+            // Add entities
+            for (const entity of _entities) {
+                _capabilities.push({
+                    type: 'entity',
+                    entityType: entity.entityType,
+                    entities: entity.entities
+                });
+            }
+            // Add wizard
+            if (_wizard) {
+                const wizardCap = {
+                    type: 'config-wizard',
+                    screen: {
+                        path: _wizard.path,
+                        title: _wizard.title,
+                        width: _wizard.width,
+                        height: _wizard.height
+                    },
+                    required: true
+                };
+                // Add shouldShow as method name reference if provided
+                if (_wizard.shouldShow) {
+                    wizardCap.shouldShow = 'shouldShowConfigWizard';
+                }
+                _capabilities.push(wizardCap);
+            }
+            // Add settings
+            if (_settings) {
+                _capabilities.push({
+                    type: 'settings-screen',
+                    path: `/plugins/${id}/settings`,
+                    name: _settings.title,
+                    screen: {
+                        path: _settings.path,
+                        title: _settings.title
+                    }
+                });
+            }
+            // ========== Build Plugin Instance ==========
+            return new BuiltPlugin(id, name, version, _capabilities, _tools, _apiRoutes, _uiConfigured ? _ui : null, _reactScreens, _htmlScreens, _wizard, _onReady, _healthCheck);
+        }
+    };
+    return builder;
+}