@majkapp/plugin-kit 1.0.17 → 1.1.0

package/dist/plugin-kit.js

@@ -7,6 +7,16 @@ exports.definePlugin = definePlugin;
 const http_1 = __importDefault(require("http"));
 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
  */
@@ -143,25 +153,132 @@ function validateEntity(entityType, entity) {
     }
     return errors;
 }
+/**
+ * Convert JSON Schema to OpenAPI Schema
+ */
+function jsonSchemaToOpenApi(schema) {
+    // OpenAPI doesn't use the $schema property
+    const { ...openApiSchema } = schema;
+    return openApiSchema;
+}
+/**
+ * Generate OpenAPI specification from routes
+ */
+function generateOpenApiSpec(pluginId, pluginName, pluginVersion, routes, baseUrl) {
+    const paths = {};
+    for (const route of routes) {
+        const openApiPath = route.path.replace(/:([A-Za-z0-9_]+)/g, '{$1}');
+        if (!paths[openApiPath]) {
+            paths[openApiPath] = {};
+        }
+        const operation = {
+            operationId: `${pluginId}_${route.name.replace(/\s+/g, '_')}`,
+            summary: route.name,
+            description: route.description,
+            tags: route.tags || [pluginId],
+            deprecated: route.deprecated
+        };
+        // Add parameters from request schema
+        if (route.requestSchema) {
+            const parameters = [];
+            // Path parameters
+            if (route.requestSchema.params) {
+                const paramProps = route.requestSchema.params.properties || {};
+                for (const [name, schema] of Object.entries(paramProps)) {
+                    parameters.push({
+                        name,
+                        in: 'path',
+                        required: route.requestSchema.params.required?.includes(name) ?? true,
+                        schema: jsonSchemaToOpenApi(schema),
+                        description: schema.description
+                    });
+                }
+            }
+            // Query parameters
+            if (route.requestSchema.query) {
+                const queryProps = route.requestSchema.query.properties || {};
+                for (const [name, schema] of Object.entries(queryProps)) {
+                    parameters.push({
+                        name,
+                        in: 'query',
+                        required: route.requestSchema.query.required?.includes(name) ?? false,
+                        schema: jsonSchemaToOpenApi(schema),
+                        description: schema.description
+                    });
+                }
+            }
+            if (parameters.length > 0) {
+                operation.parameters = parameters;
+            }
+            // Request body
+            if (route.requestSchema.body) {
+                operation.requestBody = {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: jsonSchemaToOpenApi(route.requestSchema.body)
+                        }
+                    }
+                };
+            }
+        }
+        // Response schema
+        operation.responses = {
+            '200': {
+                description: 'Successful response',
+                content: route.responseSchema ? {
+                    'application/json': {
+                        schema: jsonSchemaToOpenApi(route.responseSchema)
+                    }
+                } : {}
+            },
+            '400': {
+                description: 'Bad request'
+            },
+            '500': {
+                description: 'Internal server error'
+            }
+        };
+        paths[openApiPath][route.method.toLowerCase()] = operation;
+    }
+    return {
+        openapi: '3.0.0',
+        info: {
+            title: `${pluginName} API`,
+            version: pluginVersion,
+            description: `API documentation for the ${pluginName} MAJK plugin`
+        },
+        servers: [
+            {
+                url: baseUrl,
+                description: 'Plugin API server'
+            }
+        ],
+        paths,
+        components: {
+            schemas: {}
+        }
+    };
+}
 /**
  * Path parameter regex builder
  */
 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 };
 }
 /**
@@ -290,7 +407,11 @@ 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, 
+    // New parameter for configurable entities
+    configurableEntities) {
         this.capabilities = capabilities;
         this.tools = tools;
         this.apiRoutes = apiRoutes;
@@ -298,19 +419,74 @@ 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.cleanups = [];
         this.router = [];
+        this.transports = [];
         this.id = id;
         this.name = name;
         this.version = version;
+        this.functionRegistry = functionRegistry;
+        this.transports = transports || [];
+        this.configurableEntities = configurableEntities || [];
     }
-    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
         };
     }
     /**
@@ -349,6 +525,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))`);
@@ -379,7 +556,35 @@ class BuiltPlugin {
         }
         try {
             await this.startServer();
-            // Register API routes
+            // 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();
+                    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)
             for (const route of this.apiRoutes) {
                 const { regex, keys } = pathToRegex(route.path);
                 this.router.push({
@@ -388,17 +593,127 @@ class BuiltPlugin {
                     keys,
                     name: route.name,
                     description: route.description,
-                    handler: route.handler
+                    handler: route.handler,
+                    requestSchema: route.requestSchema,
+                    responseSchema: route.responseSchema,
+                    tags: route.tags,
+                    deprecated: route.deprecated
                 });
                 context.logger.info(`📝 Registered route: ${route.method} ${route.path} - ${route.name}`);
             }
+            // Register the discovery endpoint at /majk/plugin/api
+            const discoveryPath = '/majk/plugin/api';
+            const { regex: discoveryRegex, keys: discoveryKeys } = pathToRegex(discoveryPath);
+            this.router.push({
+                method: 'GET',
+                regex: discoveryRegex,
+                keys: discoveryKeys,
+                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;
+                }
+            });
+            context.logger.info(`📝 Registered discovery route: GET ${discoveryPath}`);
+            // Also register a simpler JSON format at /majk/plugin/routes for quick access
+            const routesPath = '/majk/plugin/routes';
+            const { regex: routesRegex, keys: routesKeys } = pathToRegex(routesPath);
+            this.router.push({
+                method: 'GET',
+                regex: routesRegex,
+                keys: routesKeys,
+                name: 'Routes List',
+                description: 'Get a simple JSON list of all available API routes',
+                handler: async (_req, _res, _ctx) => {
+                    return {
+                        plugin: {
+                            id: this.id,
+                            name: this.name,
+                            version: this.version
+                        },
+                        routes: this.apiRoutes.map(route => ({
+                            method: route.method,
+                            path: route.path,
+                            name: route.name,
+                            description: route.description,
+                            deprecated: route.deprecated,
+                            tags: route.tags,
+                            requestSchema: route.requestSchema,
+                            responseSchema: route.responseSchema
+                        })),
+                        discoveryUrl: `${this.context.http.baseUrl}/majk/plugin/api`
+                    };
+                }
+            });
+            context.logger.info(`📝 Registered routes list: GET ${routesPath}`);
             // 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`);
+            // 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}`);
@@ -526,8 +841,52 @@ class BuiltPlugin {
                     this.context.logger.debug(`← ${method} ${url} ${res.statusCode || 200} (${duration}ms)`);
                     return;
                 }
-                // API routes
-                if (req.url?.startsWith('/api/')) {
+                // Function calls (new function-first API)
+                if (req.method === 'POST' && req.url?.startsWith('/api/fn/')) {
+                    const functionName = req.url.substring('/api/fn/'.length).split('?')[0];
+                    if (this.functionRegistry && this.transports.length > 0) {
+                        // Use the first HTTP transport to handle the function call
+                        const httpTransport = this.transports.find(t => t.name === 'http');
+                        if (httpTransport) {
+                            const body = await readBody(req);
+                            const request = {
+                                method: 'POST',
+                                url: req.url,
+                                pathname: req.url.split('?')[0],
+                                query: new URL(req.url, `http://localhost:${port}`).searchParams,
+                                params: {},
+                                body,
+                                headers: req.headers
+                            };
+                            const response = makeResponse(res);
+                            await httpTransport.handleFunctionCall(functionName, request, response, {
+                                majk: this.context.majk,
+                                storage: this.context.storage,
+                                logger: this.context.logger,
+                                http: this.context.http
+                            });
+                            const duration = Date.now() - startTime;
+                            this.context.logger.debug(`← POST /api/fn/${functionName} ${res.statusCode || 200} (${duration}ms)`);
+                            return;
+                        }
+                    }
+                }
+                // Function discovery endpoint
+                if (req.method === 'GET' && req.url === '/api/fn/discovery') {
+                    if (this.functionRegistry && this.transports.length > 0) {
+                        const httpTransport = this.transports.find(t => t.name === 'http');
+                        if (httpTransport) {
+                            const discovery = httpTransport.getDiscovery();
+                            res.writeHead(200, corsHeaders({ 'Content-Type': 'application/json' }));
+                            res.end(JSON.stringify(discovery));
+                            const duration = Date.now() - startTime;
+                            this.context.logger.debug(`← GET /api/fn/discovery 200 (${duration}ms)`);
+                            return;
+                        }
+                    }
+                }
+                // API routes (including discovery endpoints) - legacy
+                if (req.url?.startsWith('/api/') || req.url?.startsWith('/majk/plugin/')) {
                     const url = new URL(req.url, `http://localhost:${port}`);
                     const pathname = url.pathname;
                     const method = req.method;
@@ -635,6 +994,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 = [];
@@ -643,6 +1005,11 @@ function definePlugin(id, name, version) {
     const _htmlScreens = [];
     const _topbars = [];
     const _entities = [];
+    const _configurableEntities = [];
+    // Function-first architecture state
+    const _functionRegistry = new registry_1.FunctionRegistryImpl(id, name, version);
+    const _transports = [];
+    let _clientConfig = null;
     let _ui = { appDir: 'ui/dist', base: '/', history: 'browser' };
     let _uiConfigured = false;
     let _wizard = null;
@@ -696,12 +1063,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) {
@@ -711,6 +1083,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,
@@ -724,9 +1097,70 @@ function definePlugin(id, name, version) {
             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 });
             }
+            // Runtime validation for request schema (TypeScript already enforces at compile-time)
+            // This catches any runtime bypasses or JavaScript usage
+            if (!route.requestSchema) {
+                throw new PluginBuildError(`API route "${route.name}" must provide a requestSchema`, `Add requestSchema to your route definition. For routes with no input, use an empty object: requestSchema: {}`, { route: route.name, path: route.path, method: route.method });
+            }
+            // Validate request schema structure
+            if (route.requestSchema) {
+                const { query, params, body } = route.requestSchema;
+                if (query && query.type !== 'object') {
+                    throw new PluginBuildError(`Query schema for route "${route.name}" must be of type "object"`, `Change query.type to "object" in your schema definition`, { route: route.name });
+                }
+                if (params && params.type !== 'object') {
+                    throw new PluginBuildError(`Params schema for route "${route.name}" must be of type "object"`, `Change params.type to "object" in your schema definition`, { route: route.name });
+                }
+                // Check for path parameters in the route
+                const pathParamMatches = route.path.match(/\/:([A-Za-z0-9_]+)/g);
+                const pathParams = pathParamMatches ? pathParamMatches.map(p => p.substring(2)) : [];
+                if (pathParams.length > 0 && !params) {
+                    throw new PluginBuildError(`Route "${route.name}" has path parameters but no params schema`, `Add params schema defining: ${pathParams.join(', ')}`, { route: route.name, pathParams });
+                }
+                if (params && pathParams.length > 0) {
+                    const schemaProps = params.properties || {};
+                    const missingParams = pathParams.filter(p => !(p in schemaProps));
+                    if (missingParams.length > 0) {
+                        throw new PluginBuildError(`Params schema missing definitions for path parameters: ${missingParams.join(', ')}`, `Add properties for: ${missingParams.join(', ')} to params.properties`, { route: route.name, missingParams });
+                    }
+                }
+            }
             _apiRoutes.push(route);
             return this;
         },
+        function(name, config) {
+            validateDescription(config.description, `Function "${name}"`);
+            try {
+                _functionRegistry.registerFunction(name, config.description, config.input, config.output, config.handler, {
+                    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 });
+            }
+            return this;
+        },
+        subscription(name, config) {
+            validateDescription(config.description, `Subscription "${name}"`);
+            try {
+                _functionRegistry.registerSubscription(name, config.description, config.input, config.output, config.handler);
+            }
+            catch (error) {
+                throw new PluginBuildError(`Failed to register subscription "${name}"`, error.message, { subscription: name });
+            }
+            return this;
+        },
+        transport(transport) {
+            _transports.push(transport);
+            return this;
+        },
+        generateClient(config) {
+            _clientConfig = config;
+            return this;
+        },
         tool(scope, spec, handler) {
             validateDescription(spec.description, `Tool "${spec.name}"`);
             if (_tools.has(spec.name)) {
@@ -762,12 +1196,97 @@ 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;
+        },
         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) {
@@ -780,6 +1299,7 @@ function definePlugin(id, name, version) {
         },
         onReady(fn) {
             _onReady = fn;
+            log(`  🏁 Registered onReady lifecycle hook`);
             return this;
         },
         health(fn) {
@@ -795,6 +1315,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) });
@@ -889,6 +1430,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';
@@ -897,7 +1442,7 @@ function definePlugin(id, name, version) {
             }
             // Add settings
             if (_settings) {
-                _capabilities.push({
+                const settingsCap = {
                     type: 'settings-screen',
                     path: `/plugins/${id}/settings`,
                     name: _settings.title,
@@ -905,14 +1450,72 @@ 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
             // Return a class that instantiates BuiltPlugin
+            // If no transports specified but functions were defined, add default HTTP transport
+            if (_functionRegistry.functions.size > 0 && _transports.length === 0) {
+                _transports.push(new transports_1.HttpTransport());
+            }
+            // TODO: Implement client generation if configured
+            if (_clientConfig) {
+                // This would generate the client files based on the function registry
+                // For now, just log that it was requested
+                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, 
+                    // Pass configurable entities
+                    _configurableEntities.length > 0 ? _configurableEntities : undefined);
                 }
             };
         }