@majkapp/plugin-kit 1.0.18 → 1.2.0

package/dist/plugin-kit.js

@@ -9,6 +9,14 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const registry_1 = require("./registry");
 const transports_1 = require("./transports");
+/**
+ * Conditional logging - suppressed in extract mode
+ */
+const log = (message) => {
+    if (process.env.PLUGIN_KIT_MODE !== 'extract') {
+        console.log(message);
+    }
+};
 /**
  * Build-time errors with clear, actionable messages
  */
@@ -257,20 +265,20 @@ function generateOpenApiSpec(pluginId, pluginName, pluginVersion, routes, baseUr
  */
 function pathToRegex(p) {
     const keys = [];
-    console.log(`[pathToRegex] Input path: ${p}`);
+    log(`[pathToRegex] Input path: ${p}`);
     // First, escape special regex characters EXCEPT the colon (for path params)
     const escaped = p.replace(/([.+*?=^!${}()[\]|\\])/g, '\\$1');
-    console.log(`[pathToRegex] After escaping: ${escaped}`);
+    log(`[pathToRegex] After escaping: ${escaped}`);
     // Then, replace path parameters with capturing groups
     const pattern = escaped.replace(/\/:([A-Za-z0-9_]+)/g, (_m, k) => {
         keys.push(k);
-        console.log(`[pathToRegex] Found param: ${k}`);
+        log(`[pathToRegex] Found param: ${k}`);
         return '/([^/]+)';
     });
-    console.log(`[pathToRegex] Final pattern: ${pattern}`);
-    console.log(`[pathToRegex] Keys: [${keys.join(', ')}]`);
+    log(`[pathToRegex] Final pattern: ${pattern}`);
+    log(`[pathToRegex] Keys: [${keys.join(', ')}]`);
     const regex = new RegExp(`^${pattern}$`);
-    console.log(`[pathToRegex] Final regex: ${regex}`);
+    log(`[pathToRegex] Final regex: ${regex}`);
     return { regex, keys };
 }
 /**
@@ -399,9 +407,13 @@ function serveSpa(ui, req, res, ctx) {
  * Main plugin class built by the fluent API
  */
 class BuiltPlugin {
-    constructor(id, name, version, capabilities, tools, apiRoutes, uiConfig, reactScreens, htmlScreens, wizard, onReadyFn, healthCheckFn, userProvidedPluginRoot, 
+    constructor(id, name, version, capabilities, tools, apiRoutes, uiConfig, reactScreens, htmlScreens, wizard, settings, onReadyFn, healthCheckFn, userProvidedPluginRoot, 
     // New parameters for function-first architecture
-    functionRegistry, transports) {
+    functionRegistry, transports, 
+    // New parameter for configurable entities
+    configurableEntities, 
+    // New parameter for secret providers
+    secretProviders) {
         this.capabilities = capabilities;
         this.tools = tools;
         this.apiRoutes = apiRoutes;
@@ -409,9 +421,12 @@ class BuiltPlugin {
         this.reactScreens = reactScreens;
         this.htmlScreens = htmlScreens;
         this.wizard = wizard;
+        this.settings = settings;
         this.onReadyFn = onReadyFn;
         this.healthCheckFn = healthCheckFn;
         this.userProvidedPluginRoot = userProvidedPluginRoot;
+        this.configurableEntities = configurableEntities;
+        this.secretProviders = secretProviders;
         this.cleanups = [];
         this.router = [];
         this.transports = [];
@@ -420,11 +435,62 @@ class BuiltPlugin {
         this.version = version;
         this.functionRegistry = functionRegistry;
         this.transports = transports || [];
+        this.configurableEntities = configurableEntities || [];
+        this.secretProviders = secretProviders || [];
     }
-    getCapabilities() {
+    async getCapabilities() {
+        // Start with static capabilities
+        const dynamicCapabilities = [...this.capabilities];
+        // Only process configurable entities if context is available (after onLoad has been called)
+        if (!this.context) {
+            // Context not set yet - return only static capabilities
+            // This happens when getCapabilities() is called before onLoad()
+            return {
+                apiVersion: 'majk.capabilities/v1',
+                capabilities: dynamicCapabilities
+            };
+        }
+        // If wizard has schema, check for config and add configurable entities
+        if (this.wizard?.schema && this.configurableEntities && this.configurableEntities.length > 0) {
+            const storageKey = this.wizard.storageKey || '_plugin_config';
+            this.context.logger.info(`[ConfigWizard] getCapabilities: checking for config at key: ${storageKey}`);
+            try {
+                // Load config from storage
+                const config = await this.context.storage.get(storageKey);
+                if (config) {
+                    this.context.logger.info(`[ConfigWizard] ✅ Config found - generating configurable entities`);
+                    this.context.logger.info(`[ConfigWizard] Config:`, JSON.stringify(config, null, 2));
+                    // Call each configurable entity factory with the config
+                    for (const ce of this.configurableEntities) {
+                        this.context.logger.info(`[ConfigWizard] Calling factory for ${ce.entityType}...`);
+                        try {
+                            const entities = ce.factory(config);
+                            this.context.logger.info(`[ConfigWizard] Factory returned ${entities.length} ${ce.entityType} entities`);
+                            if (entities.length > 0) {
+                                dynamicCapabilities.push({
+                                    type: 'entity',
+                                    entityType: ce.entityType,
+                                    entities: entities
+                                });
+                                this.context.logger.info(`[ConfigWizard] ✅ Added ${entities.length} ${ce.entityType} entities to capabilities`);
+                            }
+                        }
+                        catch (factoryError) {
+                            this.context.logger.error(`[ConfigWizard] ❌ Factory for ${ce.entityType} failed:`, factoryError.message);
+                        }
+                    }
+                }
+                else {
+                    this.context.logger.info(`[ConfigWizard] ⚠️  No config found - configurable entities will not be registered`);
+                }
+            }
+            catch (error) {
+                this.context.logger.error(`[ConfigWizard] ❌ Failed to load config:`, error.message);
+            }
+        }
         return {
             apiVersion: 'majk.capabilities/v1',
-            capabilities: this.capabilities
+            capabilities: dynamicCapabilities
         };
     }
     /**
@@ -452,6 +518,26 @@ class BuiltPlugin {
             }
         };
     }
+    async createSecretProvider(capability) {
+        const providerName = capability.name;
+        const providerDef = this.secretProviders?.find(sp => sp.name === providerName);
+        if (!providerDef) {
+            throw new PluginRuntimeError(`Secret provider "${providerName}" not found`, 'createSecretProvider', {
+                providerName,
+                availableProviders: this.secretProviders?.map(sp => sp.name) || []
+            });
+        }
+        this.context.logger.info(`[SecretProvider] Creating provider: ${providerName}`);
+        try {
+            const instance = await providerDef.factory(this.context);
+            this.context.logger.info(`[SecretProvider] ✅ Provider created: ${providerName}`);
+            return instance;
+        }
+        catch (error) {
+            this.context.logger.error(`[SecretProvider] ❌ Failed to create provider: ${providerName}`, error);
+            throw new PluginRuntimeError(`Failed to create secret provider "${providerName}"`, 'createSecretProvider', { providerName, error: error instanceof Error ? error.message : String(error) });
+        }
+    }
     async onLoad(context) {
         // Use user-provided pluginRoot (from __dirname) if available, otherwise fall back to context.pluginRoot
         // The user-provided path comes from Node's __dirname which automatically resolves to the real directory
@@ -463,6 +549,7 @@ class BuiltPlugin {
         };
         context.logger.info('═══════════════════════════════════════════════════════');
         context.logger.info(`🚀 Loading Plugin: ${this.name} (${this.id}) v${this.version}`);
+        context.logger.info(`🔧 Plugin Kit Version: @majkapp/plugin-kit@1.0.19`);
         context.logger.info(`📍 Plugin Root: ${effectivePluginRoot}`);
         if (this.userProvidedPluginRoot) {
             context.logger.info(`   (user-provided via .pluginRoot(__dirname))`);
@@ -495,10 +582,30 @@ class BuiltPlugin {
             await this.startServer();
             // Initialize transports for function-first architecture
             if (this.functionRegistry) {
+                context.logger.info('');
+                context.logger.info('🔌 Initializing Transports...');
                 for (const transport of this.transports) {
                     await transport.initialize(this.functionRegistry, this.context);
                     await transport.start();
-                    context.logger.info(`✅ ${transport.name} transport initialized`);
+                    const metadata = transport.getMetadata();
+                    context.logger.info(`  ✅ ${transport.name} transport initialized`);
+                    context.logger.info(`     • Base Path: ${metadata.endpoint}`);
+                    context.logger.info(`     • Discovery: ${metadata.discovery}`);
+                }
+                // Log registered functions
+                const functionNames = this.functionRegistry.getFunctionNames();
+                if (functionNames.length > 0) {
+                    context.logger.info('');
+                    context.logger.info(`📦 Registered ${functionNames.length} Functions:`);
+                    for (const fname of functionNames) {
+                        const func = this.functionRegistry.functions.get(fname);
+                        if (func) {
+                            context.logger.info(`  • ${fname}: ${func.description}`);
+                            if (func.deprecated) {
+                                context.logger.info(`    ⚠️  DEPRECATED`);
+                            }
+                        }
+                    }
                 }
             }
             // Register API routes (legacy)
@@ -528,6 +635,11 @@ class BuiltPlugin {
                 name: 'API Discovery',
                 description: 'Get OpenAPI specification for all plugin API routes',
                 handler: async (_req, _res, _ctx) => {
+                    // If using function-first architecture, generate spec from function registry
+                    if (this.functionRegistry && this.functionRegistry.getFunctionNames().length > 0) {
+                        return this.functionRegistry.toOpenAPISpec();
+                    }
+                    // Otherwise fall back to legacy API routes
                     const openApiSpec = generateOpenApiSpec(this.id, this.name, this.version, this.apiRoutes, this.context.http.baseUrl);
                     return openApiSpec;
                 }
@@ -570,7 +682,62 @@ class BuiltPlugin {
                 await this.onReadyFn(this.context, (fn) => this.cleanups.push(fn));
                 context.logger.info('✅ onReady hook completed');
             }
-            context.logger.info(`✅ Plugin "${this.name}" loaded successfully`);
+            // Print comprehensive summary
+            context.logger.info('');
+            context.logger.info('╔══════════════════════════════════════════════════════════╗');
+            context.logger.info('║ 🎉 PLUGIN LOADED SUCCESSFULLY                       ║');
+            context.logger.info('╟──────────────────────────────────────────────────────────╢');
+            context.logger.info('║ 🌐 API ENDPOINTS                                   ║');
+            context.logger.info('╟──────────────────────────────────────────────────────────╢');
+            // API Discovery endpoints
+            context.logger.info(`║ 🔍 Discovery:                                      ║`);
+            context.logger.info(`║    ${context.http.baseUrl}/majk/plugin/api`);
+            context.logger.info(`║    ${context.http.baseUrl}/majk/plugin/routes`);
+            // Function endpoints
+            if (this.functionRegistry && this.functionRegistry.getFunctionNames().length > 0) {
+                context.logger.info(`║                                                      ║`);
+                context.logger.info(`║ 🚀 Function Endpoints:                             ║`);
+                for (const fname of this.functionRegistry.getFunctionNames()) {
+                    context.logger.info(`║    POST ${context.http.baseUrl}/api/fn/${fname}`);
+                }
+            }
+            // Legacy API routes
+            if (this.apiRoutes.length > 0) {
+                context.logger.info(`║                                                      ║`);
+                context.logger.info(`║ 📋 Legacy API Routes:                              ║`);
+                for (const route of this.apiRoutes) {
+                    context.logger.info(`║    ${route.method} ${context.http.baseUrl}${route.path}`);
+                }
+            }
+            // UI Screens
+            const allScreens = [...this.reactScreens, ...this.htmlScreens];
+            if (allScreens.length > 0 || this.uiConfig) {
+                context.logger.info('╟──────────────────────────────────────────────────────────╢');
+                context.logger.info('║ 🕹  UI SCREENS                                      ║');
+                context.logger.info('╟──────────────────────────────────────────────────────────╢');
+                for (const screen of allScreens) {
+                    context.logger.info(`║ • ${screen.name || screen.id}`);
+                    context.logger.info(`║   ${context.http.baseUrl}${screen.route}`);
+                }
+            }
+            // Config Wizard
+            if (this.wizard) {
+                context.logger.info('╟──────────────────────────────────────────────────────────╢');
+                context.logger.info('║ 🧙 CONFIG WIZARD                                   ║');
+                context.logger.info('╟──────────────────────────────────────────────────────────╢');
+                context.logger.info(`║ ${this.wizard.title}`);
+                context.logger.info(`║ ${context.http.baseUrl}${this.wizard.path}`);
+            }
+            // Settings
+            if (this.settings) {
+                context.logger.info('╟──────────────────────────────────────────────────────────╢');
+                context.logger.info('║ ⚙️  SETTINGS                                        ║');
+                context.logger.info('╟──────────────────────────────────────────────────────────╢');
+                context.logger.info(`║ ${this.settings.title}`);
+                context.logger.info(`║ ${context.http.baseUrl}${this.settings.path}`);
+            }
+            context.logger.info('╚══════════════════════════════════════════════════════════╝');
+            context.logger.info('');
         }
         catch (error) {
             context.logger.error(`❌ Failed to load plugin "${this.name}": ${error.message}`);
@@ -851,6 +1018,9 @@ function groupByScope(tools) {
  * Create a plugin with fluent builder API
  */
 function definePlugin(id, name, version) {
+    log(`🔨 Building plugin: ${name} (${id}) v${version}`);
+    log(`📦 Plugin Kit: @majkapp/plugin-kit@1.0.19`);
+    log(``);
     const _capabilities = [];
     const _tools = new Map();
     const _toolSpecs = [];
@@ -859,6 +1029,8 @@ function definePlugin(id, name, version) {
     const _htmlScreens = [];
     const _topbars = [];
     const _entities = [];
+    const _configurableEntities = [];
+    const _secretProviders = [];
     // Function-first architecture state
     const _functionRegistry = new registry_1.FunctionRegistryImpl(id, name, version);
     const _transports = [];
@@ -916,12 +1088,17 @@ function definePlugin(id, name, version) {
             }
             const iframeUrl = `http://localhost:{port}${_ui.base}${screen.reactPath}`;
             _reactScreens.push(screen);
-            _capabilities.push({
+            log(`  🕹  Registered React screen: ${screen.name} at ${screen.route}`);
+            const capability = {
                 type: 'screen',
                 id: screen.id,
                 path: screen.route,
                 iframeUrl
-            });
+            };
+            if (screen.hash) {
+                capability.hash = screen.hash;
+            }
+            _capabilities.push(capability);
             return this;
         },
         screenHtml(screen) {
@@ -931,6 +1108,7 @@ function definePlugin(id, name, version) {
             }
             const iframeUrl = `http://localhost:{port}/__html/${encodeURIComponent(screen.id)}`;
             _htmlScreens.push(screen);
+            log(`  📋 Registered HTML screen: ${screen.name} at ${screen.route}`);
             _capabilities.push({
                 type: 'screen',
                 id: screen.id,
@@ -982,6 +1160,8 @@ function definePlugin(id, name, version) {
                     tags: config.tags,
                     deprecated: config.deprecated
                 });
+                // Log function registration
+                log(`  📦 Registered function: ${name} - ${config.description}`);
             }
             catch (error) {
                 throw new PluginBuildError(`Failed to register function "${name}"`, error.message, { function: name });
@@ -1041,12 +1221,108 @@ function definePlugin(id, name, version) {
             // Type-safe wrapper for team member entities
             return this.entity('teamMember', members);
         },
+        configurableEntity(entityType, factory) {
+            _configurableEntities.push({ entityType, factory });
+            log(`  🔧 Registered configurable entity: ${entityType} (requires config)`);
+            return this;
+        },
+        configurableMcp(factory) {
+            _configurableEntities.push({ entityType: 'mcpServer', factory });
+            log(`  🔧 Registered configurable MCP server (requires config)`);
+            return this;
+        },
+        configurableTeamMember(factory) {
+            _configurableEntities.push({ entityType: 'teamMember', factory });
+            log(`  🔧 Registered configurable team member (requires config)`);
+            return this;
+        },
+        secretProvider(def) {
+            if (!def.name) {
+                throw new PluginBuildError('Secret provider requires a name', 'Provide a name in the SecretProviderDef', { provided: def });
+            }
+            if (!def.factory) {
+                throw new PluginBuildError('Secret provider requires a factory function', 'Provide a factory function that returns a SecretProviderInstance', { name: def.name });
+            }
+            _secretProviders.push(def);
+            log(`  🔐 Registered secret provider: ${def.name} (priority: ${def.priority || 100})`);
+            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;
+            // Auto-generate config management functions if schema is provided
+            if (def.schema) {
+                const storageKey = def.storageKey || '_plugin_config';
+                log(`  🔧 Schema provided - auto-generating config functions`);
+                log(`     Storage key: ${storageKey}`);
+                // Auto-generate updateConfig function
+                _functionRegistry.registerFunction('updateConfig', 'Update plugin configuration (auto-generated)', def.schema, {
+                    type: 'object',
+                    properties: {
+                        success: { type: 'boolean' },
+                        message: { type: 'string' },
+                        data: def.schema,
+                        error: { type: 'string' }
+                    },
+                    required: ['success']
+                }, async (config, ctx) => {
+                    ctx.logger.info(`[ConfigWizard] updateConfig called`);
+                    ctx.logger.info(`[ConfigWizard] Config to save:`, JSON.stringify(config, null, 2));
+                    try {
+                        // Save to storage
+                        await ctx.storage.set(storageKey, config);
+                        ctx.logger.info(`[ConfigWizard] ✅ Config saved to storage key: ${storageKey}`);
+                        return {
+                            success: true,
+                            message: 'Configuration saved successfully',
+                            data: config
+                        };
+                    }
+                    catch (error) {
+                        ctx.logger.error(`[ConfigWizard] ❌ Failed to save config:`, error.message);
+                        return {
+                            success: false,
+                            error: error.message
+                        };
+                    }
+                }, { tags: ['config'], deprecated: false });
+                // Auto-generate getConfig function
+                _functionRegistry.registerFunction('getConfig', 'Get current plugin configuration (auto-generated)', {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: false
+                }, {
+                    type: 'object',
+                    properties: {
+                        success: { type: 'boolean' },
+                        data: def.schema,
+                        error: { type: 'string' }
+                    },
+                    required: ['success']
+                }, async (_input, ctx) => {
+                    ctx.logger.info(`[ConfigWizard] getConfig called`);
+                    try {
+                        const config = await ctx.storage.get(storageKey);
+                        if (config) {
+                            ctx.logger.info(`[ConfigWizard] ✅ Config loaded from storage`);
+                            return { success: true, data: config };
+                        }
+                        else {
+                            ctx.logger.info(`[ConfigWizard] ⚠️  No config found in storage`);
+                            return { success: false, error: 'No configuration found' };
+                        }
+                    }
+                    catch (error) {
+                        ctx.logger.error(`[ConfigWizard] ❌ Failed to load config:`, error.message);
+                        return { success: false, error: error.message };
+                    }
+                }, { tags: ['config'], deprecated: false });
+                log(`  ✅ Auto-generated: updateConfig()`);
+                log(`  ✅ Auto-generated: getConfig()`);
+            }
             return this;
         },
         settings(def) {
@@ -1059,6 +1335,7 @@ function definePlugin(id, name, version) {
         },
         onReady(fn) {
             _onReady = fn;
+            log(`  🏁 Registered onReady lifecycle hook`);
             return this;
         },
         health(fn) {
@@ -1074,6 +1351,27 @@ function definePlugin(id, name, version) {
         },
         build() {
             // ========== Build-Time Validation ==========
+            // Validate configurable entities require configWizard with schema
+            if (_configurableEntities.length > 0) {
+                if (!_wizard) {
+                    throw new PluginBuildError('Configurable entities require configWizard', 'You used .configurableTeamMember(), .configurableMcp(), or .configurableEntity() but did not call .configWizard()', {
+                        configurableEntities: _configurableEntities.map(ce => ce.entityType),
+                        hint: 'Add .configWizard({ schema: YourSchema, ... }) to your plugin'
+                    });
+                }
+                if (!_wizard.schema) {
+                    throw new PluginBuildError('Configurable entities require configWizard with schema', 'You used configurable entities but .configWizard() does not have a schema property', {
+                        configurableEntities: _configurableEntities.map(ce => ce.entityType),
+                        hint: 'Add schema property to .configWizard({ schema: YourSchema, ... })'
+                    });
+                }
+                log(`  ✅ Validated: ${_configurableEntities.length} configurable entities with config schema`);
+            }
+            // Warn if config wizard has schema but no configurable entities
+            if (_wizard?.schema && _configurableEntities.length === 0) {
+                log(`  ⚠️  Warning: configWizard has schema but no configurable entities defined`);
+                log(`     Consider using .configurableTeamMember() or .configurableMcp() to take advantage of the config`);
+            }
             // 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) });
@@ -1156,6 +1454,28 @@ function definePlugin(id, name, version) {
                     entities: entity.entities
                 });
             }
+            // Add secret providers
+            for (const provider of _secretProviders) {
+                const providerCap = {
+                    type: 'secret-provider',
+                    name: provider.name,
+                    priority: provider.priority || 100,
+                    scopes: provider.scopes || ['global', 'project', 'integration']
+                };
+                if (provider.description) {
+                    providerCap.metadata = providerCap.metadata || {};
+                    providerCap.metadata.description = provider.description;
+                }
+                if (provider.icon) {
+                    providerCap.metadata = providerCap.metadata || {};
+                    providerCap.metadata.icon = provider.icon;
+                }
+                if (provider.tags) {
+                    providerCap.metadata = providerCap.metadata || {};
+                    providerCap.metadata.tags = provider.tags;
+                }
+                _capabilities.push(providerCap);
+            }
             // Add wizard
             if (_wizard) {
                 const wizardCap = {
@@ -1168,6 +1488,10 @@ function definePlugin(id, name, version) {
                     },
                     required: true
                 };
+                // Add hash if provided
+                if (_wizard.hash) {
+                    wizardCap.screen.hash = _wizard.hash;
+                }
                 // Add shouldShow as method name reference if provided
                 if (_wizard.shouldShow) {
                     wizardCap.shouldShow = 'shouldShowConfigWizard';
@@ -1176,7 +1500,7 @@ function definePlugin(id, name, version) {
             }
             // Add settings
             if (_settings) {
-                _capabilities.push({
+                const settingsCap = {
                     type: 'settings-screen',
                     path: `/plugins/${id}/settings`,
                     name: _settings.title,
@@ -1184,7 +1508,12 @@ function definePlugin(id, name, version) {
                         path: _settings.path,
                         title: _settings.title
                     }
-                });
+                };
+                // Add hash if provided
+                if (_settings.hash) {
+                    settingsCap.screen.hash = _settings.hash;
+                }
+                _capabilities.push(settingsCap);
             }
             // ========== Build Plugin Class ==========
             // MAJK expects a class/constructor, not an instance
@@ -1197,13 +1526,56 @@ function definePlugin(id, name, version) {
             if (_clientConfig) {
                 // This would generate the client files based on the function registry
                 // For now, just log that it was requested
-                console.log('Client generation requested:', _clientConfig);
+                log('Client generation requested: ' + JSON.stringify(_clientConfig));
+            }
+            // Check for extract mode - output metadata and exit
+            if (process.env.PLUGIN_KIT_MODE === 'extract') {
+                const metadata = {
+                    id,
+                    name,
+                    version,
+                    functions: Array.from(_functionRegistry.functions.entries()).map(([fname, func]) => ({
+                        name: fname,
+                        description: func.description,
+                        input: func.input,
+                        output: func.output,
+                        tags: func.tags,
+                        deprecated: func.deprecated
+                    })),
+                    screens: [..._reactScreens, ..._htmlScreens].map(s => ({
+                        id: s.id,
+                        name: s.name,
+                        route: s.route,
+                        type: 'reactPath' in s ? 'react' : 'html'
+                    })),
+                    tools: _toolSpecs.map(t => ({
+                        name: t.spec.name,
+                        description: t.spec.description,
+                        scope: t.scope
+                    })),
+                    openapi: _functionRegistry.toOpenAPISpec()
+                };
+                // Write to file specified by env variable
+                const outputFile = process.env.PLUGIN_KIT_OUTPUT;
+                if (outputFile) {
+                    fs_1.default.writeFileSync(outputFile, JSON.stringify(metadata, null, 2), 'utf-8');
+                    console.log(`Metadata written to ${outputFile}`);
+                }
+                else {
+                    // Fallback to stdout if no file specified
+                    console.log(JSON.stringify(metadata, null, 2));
+                }
+                process.exit(0);
             }
             return class extends BuiltPlugin {
                 constructor() {
-                    super(id, name, version, _capabilities, _tools, _apiRoutes, _uiConfigured ? _ui : null, _reactScreens, _htmlScreens, _wizard, _onReady, _healthCheck, _pluginRoot, 
+                    super(id, name, version, _capabilities, _tools, _apiRoutes, _uiConfigured ? _ui : null, _reactScreens, _htmlScreens, _wizard, _settings, _onReady, _healthCheck, _pluginRoot, 
                     // Pass function registry and transports if functions were defined
-                    _functionRegistry.functions.size > 0 ? _functionRegistry : undefined, _transports.length > 0 ? _transports : undefined);
+                    _functionRegistry.functions.size > 0 ? _functionRegistry : undefined, _transports.length > 0 ? _transports : undefined, 
+                    // Pass configurable entities
+                    _configurableEntities.length > 0 ? _configurableEntities : undefined, 
+                    // Pass secret providers
+                    _secretProviders.length > 0 ? _secretProviders : undefined);
                 }
             };
         }