@tamyla/clodo-framework 4.0.13 → 4.0.14

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [4.0.14](https://github.com/tamylaa/clodo-framework/compare/v4.0.13...v4.0.14) (2026-01-19)
+
+
+### Bug Fixes
+
+* middleware packaging, generators, tests, and packaged-artifact smoke test ([b001434](https://github.com/tamylaa/clodo-framework/commit/b001434697da2145e8778b5c0afd02275cd1604e))
+* resolve Windows filesystem timing issues in tests ([7092ca6](https://github.com/tamylaa/clodo-framework/commit/7092ca6ffc230a19d25c96333c0313ead1739f15))
+
 ## [4.0.13](https://github.com/tamylaa/clodo-framework/compare/v4.0.12...v4.0.13) (2025-12-17)
 
 
@@ -173,6 +181,9 @@ Benefits:
   - Moved 13 root-level documentation files to appropriate i-docs categories
   - Root directory now contains only essential project files (config, package.json, README, etc.)
 
+* **Documentation**: Added `docs/HOWTO_CONSUME_CLODO_FRAMEWORK.md` — a concise consumer guide covering CLI usage, public exports, packaging troubleshooting, and recommended consumption patterns.
+* **Middleware Architecture**: Introduce contract-first middleware generation (v4.1 candidate) with `MiddlewareRegistry` and `MiddlewareComposer` to reduce duplication and improve testability. Added a migration tool `scripts/migration/migrate-middleware-legacy-to-contract.js` and a `--middleware-strategy` CLI flag to opt into `legacy` generator output.
+
 * **Configuration Management**: Eliminated hard-coded values from source code
   - Moved domain defaults from ServiceCreator to `validation-config.json`
   - Added configuration hierarchy: CLI option → config file → fallback default

package/README.md

@@ -199,6 +199,13 @@ import { CloudflareAPI } from '@tamyla/clodo-framework/utils/cloudflare';
 
 If you need functionality that's currently only in `bin/`, please open an issue - we'll consider adding it to the public API.
 
+---
+
+## How to consume (quick)
+A short guide and best practices for consuming `@tamyla/clodo-framework` are available in the docs: [docs/HOWTO_CONSUME_CLODO_FRAMEWORK.md](./docs/HOWTO_CONSUME_CLODO_FRAMEWORK.md). This file includes quickstart steps, public export guidance, CLI usage, and troubleshooting tips for packaged artifacts.
+
+If you'd like this information added to `clodo.dev`, I can prepare a small website PR as well.
+
 ## Project Structure
 
 The project is organized for maximum clarity and maintainability:

package/dist/cli/commands/create.js

@@ -9,7 +9,7 @@ import chalk from 'chalk';
 import { Clodo, ConfigLoader } from '@tamyla/clodo-framework';
 import { StandardOptions } from '../../lib/shared/utils/cli-options.js';
 export function registerCreateCommand(program) {
-  const command = program.command('create').description('Create a new Clodo service with conversational setup').option('-n, --non-interactive', 'Run in non-interactive mode with all required parameters').option('--service-name <name>', 'Service name (required in non-interactive mode)').option('--service-type <type>', 'Service type: data-service, auth-service, content-service, api-gateway, generic', 'generic').option('--domain-name <domain>', 'Domain name (required in non-interactive mode)').option('--cloudflare-token <token>', 'Cloudflare API token (required in non-interactive mode)').option('--cloudflare-account-id <id>', 'Cloudflare account ID (required in non-interactive mode)').option('--cloudflare-zone-id <id>', 'Cloudflare zone ID (required in non-interactive mode)').option('--environment <env>', 'Target environment: development, staging, production', 'development').option('--output-path <path>', 'Output directory for generated service', '.').option('--template-path <path>', 'Path to service templates', './templates').option('--force', 'Skip confirmation prompts').option('--validate', 'Validate service after creation');
+  const command = program.command('create').description('Create a new Clodo service with conversational setup').option('-n, --non-interactive', 'Run in non-interactive mode with all required parameters').option('--service-name <name>', 'Service name (required in non-interactive mode)').option('--service-type <type>', 'Service type: data-service, auth-service, content-service, api-gateway, generic', 'generic').option('--domain-name <domain>', 'Domain name (required in non-interactive mode)').option('--cloudflare-token <token>', 'Cloudflare API token (required in non-interactive mode)').option('--cloudflare-account-id <id>', 'Cloudflare account ID (required in non-interactive mode)').option('--cloudflare-zone-id <id>', 'Cloudflare zone ID (required in non-interactive mode)').option('--environment <env>', 'Target environment: development, staging, production', 'development').option('--output-path <path>', 'Output directory for generated service', '.').option('--template-path <path>', 'Path to service templates', './templates').option('--middleware-strategy <strategy>', 'Middleware generation strategy: contract|legacy', 'contract').option('--force', 'Skip confirmation prompts').option('--validate', 'Validate service after creation');
 
   // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
   StandardOptions.define(command).action(async options => {
@@ -40,6 +40,7 @@ export function registerCreateCommand(program) {
         domain: mergedOptions.domainName,
         environment: mergedOptions.environment,
         outputPath: mergedOptions.outputPath,
+        middlewareStrategy: mergedOptions.middlewareStrategy,
         interactive: !mergedOptions.nonInteractive,
         credentials: {
           token: mergedOptions.cloudflareToken,

package/dist/middleware/Composer.js

@@ -0,0 +1,38 @@
+// Middleware composer that runs middleware in sequence and supports short-circuiting
+export class MiddlewareComposer {
+  static compose(...middlewares) {
+    const chain = middlewares.filter(Boolean);
+    return {
+      async execute(request, handler) {
+        // Preprocess/auth/validate phases
+        for (const m of chain) {
+          if (typeof m.preprocess === 'function') {
+            const res = await m.preprocess(request);
+            if (res) return res;
+          }
+          if (typeof m.authenticate === 'function') {
+            const res = await m.authenticate(request);
+            if (res) return res;
+          }
+          if (typeof m.validate === 'function') {
+            const res = await m.validate(request);
+            if (res) return res;
+          }
+        }
+
+        // Call the final handler
+        let response = await handler(request);
+
+        // Postprocess in reverse order
+        for (const m of chain.slice().reverse()) {
+          if (typeof m.postprocess === 'function') {
+            const updated = await m.postprocess(response);
+            // Allow middleware to replace response
+            if (updated instanceof Response) response = updated;
+          }
+        }
+        return response;
+      }
+    };
+  }
+}

package/dist/middleware/Registry.js

@@ -0,0 +1,14 @@
+// Registry for service-specific middleware implementations
+export class MiddlewareRegistry {
+  static implementations = new Map();
+  static register(serviceName, middleware) {
+    if (!serviceName) throw new Error('serviceName is required');
+    this.implementations.set(serviceName, middleware);
+  }
+  static get(serviceName) {
+    return this.implementations.get(serviceName) || null;
+  }
+  static clear() {
+    this.implementations.clear();
+  }
+}

package/dist/middleware/index.js

@@ -0,0 +1,3 @@
+export { MiddlewareRegistry } from './Registry.js';
+export { MiddlewareComposer } from './Composer.js';
+export * as Shared from './shared/index.js';

package/dist/middleware/shared/basicAuth.js

@@ -0,0 +1,21 @@
+export function basicAuth({
+  realm = 'Restricted'
+} = {}) {
+  return {
+    authenticate(request) {
+      const auth = request.headers.get('Authorization');
+      if (!auth) {
+        return new Response(JSON.stringify({
+          error: 'Unauthorized'
+        }), {
+          status: 401,
+          headers: {
+            'Content-Type': 'application/json',
+            'WWW-Authenticate': `Basic realm="${realm}"`
+          }
+        });
+      }
+      return null;
+    }
+  };
+}

package/dist/middleware/shared/cors.js

@@ -0,0 +1,28 @@
+export function cors(options = {}) {
+  const origin = options.origin || '*';
+  const allowMethods = options.methods || 'GET, POST, PUT, DELETE, OPTIONS';
+  const allowHeaders = options.headers || 'Content-Type, Authorization';
+  return {
+    preprocess(request) {
+      if (request.method === 'OPTIONS') {
+        const headers = new Headers();
+        headers.set('Access-Control-Allow-Origin', origin);
+        headers.set('Access-Control-Allow-Methods', allowMethods);
+        headers.set('Access-Control-Allow-Headers', allowHeaders);
+        return new Response(null, {
+          status: 204,
+          headers
+        });
+      }
+      return null;
+    },
+    postprocess(response) {
+      const headers = new Headers(response.headers);
+      headers.set('Access-Control-Allow-Origin', origin);
+      return new Response(response.body, {
+        ...response,
+        headers
+      });
+    }
+  };
+}

package/dist/middleware/shared/index.js

@@ -0,0 +1,3 @@
+export { cors } from './cors.js';
+export { logging } from './logging.js';
+export { basicAuth } from './basicAuth.js';

package/dist/middleware/shared/logging.js

@@ -0,0 +1,14 @@
+export function logging(options = {}) {
+  const level = options.level || 'info';
+  return {
+    preprocess(request) {
+      try {
+        const path = new URL(request.url).pathname;
+        console.log(`[${new Date().toISOString()}] ${level.toUpperCase()} ${request.method} ${path}`);
+      } catch (e) {
+        // Best-effort logging - do not throw
+      }
+      return null;
+    }
+  };
+}

package/dist/service-management/GenerationEngine.js

@@ -52,6 +52,8 @@ export class GenerationEngine {
     this.templatesDir = options.templatesDir || join(__dirname, '..', '..', 'templates');
     this.outputDir = options.outputDir || process.cwd();
     this.force = options.force || false;
+    // Default middleware strategy: 'contract' (can be overridden per-generation)
+    this.middlewareStrategy = options.middlewareStrategy || 'contract';
 
     // Initialize generator registry for centralized management
     this.generatorRegistry = new GeneratorRegistry({
@@ -192,7 +194,7 @@ export class GenerationEngine {
       },
       generateServiceMiddleware: {
         generator: 'serviceMiddlewareGenerator',
-        returnPath: 'src/middleware.js'
+        returnPath: 'src/middleware/service-middleware.js'
       },
       generateServiceUtils: {
         generator: 'serviceUtilsGenerator',
@@ -283,6 +285,8 @@ export class GenerationEngine {
       // Only create proxy method if it doesn't already exist
       if (!this[methodName]) {
         this[methodName] = async function (...args) {
+          // Allow per-call overrides (apply BEFORE building context so context picks it up)
+          if (args[0] && args[0].middlewareStrategy) this.middlewareStrategy = args[0].middlewareStrategy;
           const context = this.buildContext(methodName, ...args);
           const generator = this[config.generator];
           const result = await generator.generate(context);
@@ -315,10 +319,12 @@ export class GenerationEngine {
     }
 
     // For most methods: (coreInputs, confirmedValues, servicePath)
+    // Include middlewareStrategy so generators can adapt their output
     return {
       coreInputs: args[0],
       confirmedValues: args[1],
-      servicePath: args[2]
+      servicePath: args[2],
+      middlewareStrategy: this.middlewareStrategy
     };
   }
 
@@ -334,6 +340,11 @@ export class GenerationEngine {
       outputPath: this.outputDir,
       ...options
     };
+
+    // Allow per-generation override of middleware strategy
+    if (config.middlewareStrategy) {
+      this.middlewareStrategy = config.middlewareStrategy;
+    }
     console.log('⚙️  Tier 3: Automated Generation');
     console.log('Generating 67+ configuration files and service components...\n');
     try {

package/dist/service-management/ServiceOrchestrator.js

@@ -25,6 +25,8 @@ export class ServiceOrchestrator {
     this.interactive = options.interactive !== false;
     this.outputPath = options.outputPath || '.';
     this.templatePath = options.templatePath || './templates';
+    // Middleware strategy for generation: 'contract' (default) or 'legacy'
+    this.middlewareStrategy = options.middlewareStrategy || 'contract';
 
     // Initialize modular handler components
     this.inputHandler = new InputHandler({
@@ -63,7 +65,8 @@ export class ServiceOrchestrator {
       console.log(chalk.yellow('⚙️  Tier 3: Automated Generation'));
       console.log(chalk.white('Generating 67 configuration files and service components...\n'));
       const generationResult = await this.generationHandler.generateService(coreInputs, confirmedValues, {
-        outputPath: this.outputPath
+        outputPath: this.outputPath,
+        middlewareStrategy: this.middlewareStrategy
       });
 
       // Display results
@@ -87,7 +90,8 @@ export class ServiceOrchestrator {
 
       // Generate service using GenerationHandler
       const generationResult = await this.generationHandler.generateService(coreInputs, confirmedValues, {
-        outputPath: this.outputPath
+        outputPath: this.outputPath,
+        middlewareStrategy: this.middlewareStrategy
       });
       console.log(chalk.green(`✓ Service "${coreInputs.serviceName}" created successfully`));
     } catch (error) {

package/dist/service-management/generators/code/ServiceMiddlewareGenerator.js

@@ -21,8 +21,13 @@ export class ServiceMiddlewareGenerator extends BaseGenerator {
     if (!this.shouldGenerate(context)) {
       return null;
     }
-    const middlewareContent = `/**
- * ${confirmedValues.displayName} - Service Middleware
+
+    // Allow legacy strategy if requested by context
+    const strategy = context && context.middlewareStrategy ? context.middlewareStrategy : 'contract';
+    let middlewareContent;
+    if (strategy === 'legacy') {
+      middlewareContent = `/**
+ * ${confirmedValues.displayName} - Service Middleware (LEGACY)
  *
  * Generated by Clodo Framework GenerationEngine
  * Service Type: ${coreInputs.serviceType}
@@ -47,19 +52,19 @@ export function createServiceMiddleware(serviceConfig, env) {
         headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
       }
 
-      ${confirmedValues.features.logging ? `
+      ${confirmedValues.features && confirmedValues.features.logging ? `
       // Request logging
-      console.log(\`[\${new Date().toISOString()}] \${request.method} \${request.url}\`);` : ''}
+      console.log('[' + new Date().toISOString() + '] ' + request.method + ' ' + request.url);` : ''}
 
-      ${confirmedValues.features.rateLimiting ? `
+      ${confirmedValues.features && confirmedValues.features.rateLimiting ? `
       // Rate limiting (placeholder - implement based on requirements)
       // This would typically check request frequency and block if over limit` : ''}
 
-      ${confirmedValues.features.authentication ? `
+      ${confirmedValues.features && confirmedValues.features.authentication ? `
       // Authentication middleware (placeholder)
       // This would validate JWT tokens, API keys, etc.` : ''}
 
-      ${confirmedValues.features.authorization ? `
+      ${confirmedValues.features && confirmedValues.features.authorization ? `
       // Authorization middleware (placeholder)
       // This would check user permissions and roles` : ''}
 
@@ -77,11 +82,11 @@ export function createServiceMiddleware(serviceConfig, env) {
       headers.set('X-Version', '${confirmedValues.version}');
       headers.set('X-Response-Time', Date.now().toString());
 
-      ${confirmedValues.features.monitoring ? `
+      ${confirmedValues.features && confirmedValues.features.monitoring ? `
       // Response monitoring
-      console.log(\`Response: \${response.status} (\${Date.now()}ms)\`);` : ''}
+      console.log('Response: ' + response.status + ' (' + Date.now() + 'ms)');` : ''}
 
-      ${confirmedValues.features.caching ? `
+      ${confirmedValues.features && confirmedValues.features.caching ? `
       // Cache headers (placeholder - implement based on content type)
       if (response.status === 200) {
         headers.set('Cache-Control', 'public, max-age=300'); // 5 minutes
@@ -95,6 +100,35 @@ export function createServiceMiddleware(serviceConfig, env) {
   };
 }
 `;
+    } else {
+      middlewareContent = `/**
+ * ${confirmedValues.displayName} - Service Middleware
+ *
+ * Generated by Clodo Framework GenerationEngine
+ * Service Type: ${coreInputs.serviceType}
+ */
+
+// Service middleware contract skeleton - minimal and opt-in
+export default class ${confirmedValues.packageName || confirmedValues.serviceName ? confirmedValues.serviceName : 'Service'}Middleware {
+  // Implement only the hooks you need
+  async preprocess(request) { return null; }
+  async authenticate(request) { return null; }
+  async validate(request) { return null; }
+  async postprocess(response) { return response; }
+}
+
+// Optional registration helper - Worker generator will call this to register
+export function registerMiddleware(registry, serviceName) {
+  if (!registry || typeof registry.register !== 'function') return;
+  try {
+    registry.register(serviceName || '${coreInputs.serviceName}', new (exports.default || ${confirmedValues.packageName || confirmedValues.serviceName ? confirmedValues.serviceName : 'Service'}Middleware)());
+  } catch (e) {
+    // Non-fatal - allow services to manually register if needed
+  }
+}
+
+`;
+    }
     const filePath = join(servicePath, 'src', 'middleware', 'service-middleware.js');
 
     // Ensure directory exists
@@ -104,6 +138,118 @@ export function createServiceMiddleware(serviceConfig, env) {
     });
     writeFileSync(filePath, middlewareContent, 'utf8');
     this.logger.info(`Generated: ${filePath}`);
+
+    // Also generate a lightweight runtime helper for middleware composition and registry
+    const runtimeContent = `// Lightweight middleware runtime for generated services
+export const MiddlewareRegistry = (() => {
+  const map = new Map();
+  return {
+    register(serviceName, instance) { map.set(serviceName, instance); },
+    get(serviceName) { return map.get(serviceName) || null; },
+    clear() { map.clear(); }
+  };
+})();
+
+export const MiddlewareComposer = {
+  compose(...middlewares) {
+    const chain = middlewares.filter(Boolean);
+    return {
+      async execute(request, handler) {
+        let req = request;
+        for (const m of chain) {
+          if (typeof m.preprocess === 'function') {
+            const res = await m.preprocess(req);
+            if (res) return res;
+          }
+          if (typeof m.authenticate === 'function') {
+            const res = await m.authenticate(req);
+            if (res) return res;
+          }
+          if (typeof m.validate === 'function') {
+            const res = await m.validate(req);
+            if (res) return res;
+          }
+        }
+        let response = await handler(req);
+        for (const m of chain.slice().reverse()) {
+          if (typeof m.postprocess === 'function') {
+            const updated = await m.postprocess(response);
+            if (updated instanceof Response) response = updated;
+          }
+        }
+        return response;
+      }
+    };
+  }
+};
+`;
+    const runtimePath = join(servicePath, 'src', 'middleware', 'runtime.js');
+    writeFileSync(runtimePath, runtimeContent, 'utf8');
+    this.logger.info(`Generated: ${runtimePath}`);
+
+    // Minimal shared implementations (copied into generated service for self-containment)
+    const sharedDir = join(servicePath, 'src', 'middleware', 'shared');
+    mkdirSync(sharedDir, {
+      recursive: true
+    });
+    const corsContent = `export function cors(options = {}) {
+  const origin = options.origin || '*';
+  const allowMethods = options.methods || 'GET, POST, PUT, DELETE, OPTIONS';
+  const allowHeaders = options.headers || 'Content-Type, Authorization';
+
+  return {
+    preprocess(request) {
+      if (request.method === 'OPTIONS') {
+        const headers = new Headers();
+        headers.set('Access-Control-Allow-Origin', origin);
+        headers.set('Access-Control-Allow-Methods', allowMethods);
+        headers.set('Access-Control-Allow-Headers', allowHeaders);
+        return new Response(null, { status: 204, headers });
+      }
+      return null;
+    },
+    postprocess(response) {
+      const headers = new Headers(response.headers);
+      headers.set('Access-Control-Allow-Origin', origin);
+      return new Response(response.body, { ...response, headers });
+    }
+  };
+}
+`;
+    const loggingContent = `export function logging(options = {}) {
+  const level = options.level || 'info';
+  return {
+    preprocess(request) {
+      try {
+        const path = new URL(request.url).pathname;
+        console.log('[' + new Date().toISOString() + '] ' + level.toUpperCase() + ' ' + request.method + ' ' + path);
+      } catch (e) {}
+      return null;
+    }
+  };
+}
+`;
+    const basicAuthContent = `export function basicAuth({ realm = 'Restricted' } = {}) {
+  return {
+    authenticate(request) {
+      const auth = request.headers.get('Authorization');
+      if (!auth) {
+        return new Response(JSON.stringify({ error: 'Unauthorized' }), {
+          status: 401,
+          headers: { 'Content-Type': 'application/json', 'WWW-Authenticate': 'Basic realm="' + realm + '"' }
+        });
+      }
+      return null;
+    }
+  };
+}
+`;
+    writeFileSync(join(sharedDir, 'cors.js'), corsContent, 'utf8');
+    writeFileSync(join(sharedDir, 'logging.js'), loggingContent, 'utf8');
+    writeFileSync(join(sharedDir, 'basicAuth.js'), basicAuthContent, 'utf8');
+    const indexContent = `export { cors } from './cors.js';\nexport { logging } from './logging.js';\nexport { basicAuth } from './basicAuth.js';\n`;
+    writeFileSync(join(sharedDir, 'index.js'), indexContent, 'utf8');
+    this.logger.info(`Generated shared middleware in: ${sharedDir}`);
     return filePath;
   }
 

package/dist/service-management/generators/code/WorkerIndexGenerator.js

@@ -70,7 +70,8 @@ export class WorkerIndexGenerator extends BaseGenerator {
 
 import { domains } from '../config/domains.js';
 import { createServiceHandlers } from '../handlers/service-handlers.js';
-import { createServiceMiddleware } from '../middleware/service-middleware.js';
+import { MiddlewareRegistry, MiddlewareComposer } from '../middleware/runtime.js';
+import * as Shared from '../middleware/shared/index.js';
 
 export default {
   async fetch(request, env, ctx) {
@@ -78,16 +79,81 @@ export default {
       // Get service configuration
       const serviceConfig = domains['${coreInputs.serviceName}'];
 
-      // Apply middleware
-      const middleware = createServiceMiddleware(serviceConfig, env);
-      const processedRequest = await middleware.processRequest(request);
+      // Build shared middleware instances
+      const sharedMiddlewares = [
+        Shared.cors({ origin: serviceConfig.corsPolicy || '*' }),
+        Shared.logging({ level: serviceConfig.logLevel || 'info' })
+      ];
 
-      // Route to appropriate handler
-      const handlers = createServiceHandlers(serviceConfig, env);
-      const response = await handlers.handleRequest(processedRequest, ctx);
+      // Lazy-load service middleware and support legacy factory compatibility
+      let serviceMiddlewareInstance = null;
+      let legacyFactory = null;
 
-      // Apply response middleware
-      return await middleware.processResponse(response);
+      try {
+        const mod = await import('../middleware/service-middleware.js');
+
+        if (mod?.registerMiddleware) {
+          // New-style registration helper
+          mod.registerMiddleware(MiddlewareRegistry, serviceConfig.name);
+          serviceMiddlewareInstance = MiddlewareRegistry.get(serviceConfig.name);
+        } else if (mod?.default) {
+          const def = mod.default;
+          // If the default is a class (constructor), instantiate and register
+          if (typeof def === 'function' && def.prototype) {
+            try {
+              const instance = new def();
+              MiddlewareRegistry.register(serviceConfig.name, instance);
+              serviceMiddlewareInstance = instance;
+            } catch (e) {
+              // ignore instantiation errors
+            }
+          } else if (typeof def === 'function') {
+            // Legacy factory exported as default
+            legacyFactory = def;
+          }
+        } else if (mod?.createServiceMiddleware) {
+          legacyFactory = mod.createServiceMiddleware;
+        }
+      } catch (e) {
+        // No service-specific middleware found - continue with shared only
+      }
+
+      // Compose final middleware chain
+      let chain;
+
+      if (legacyFactory) {
+        const legacyInstance = legacyFactory(serviceConfig, env);
+        const adapter = {
+          preprocess: async (req) => {
+            if (legacyInstance && typeof legacyInstance.processRequest === 'function') {
+              const processed = await legacyInstance.processRequest(req);
+              if (processed instanceof Response) return processed; // short-circuit
+              return null; // continue (legacy returns a Request)
+            }
+            return null;
+          },
+          postprocess: async (res) => {
+            if (legacyInstance && typeof legacyInstance.processResponse === 'function') {
+              const r = await legacyInstance.processResponse(res);
+              return r instanceof Response ? r : res;
+            }
+            return res;
+          }
+        };
+
+        chain = MiddlewareComposer.compose(...sharedMiddlewares, adapter);
+      } else {
+        const svcMw = serviceMiddlewareInstance || MiddlewareRegistry.get(serviceConfig.name);
+        chain = MiddlewareComposer.compose(...sharedMiddlewares, svcMw);
+      }
+
+      // Execute middleware chain with final handler
+      const response = await chain.execute(request, async (req) => {
+        const handlers = createServiceHandlers(serviceConfig, env);
+        return handlers.handleRequest(req, ctx);
+      });
+
+      return response;
 
     } catch (error) {
       console.error('Worker error:', error);

package/dist/simple-api.js

@@ -25,7 +25,38 @@ export class Clodo {
    * @returns {Promise<Object>} Service creation result
    */
   static async createService(options = {}) {
-    return await ServiceOrchestrator.create(options);
+    // Instantiate orchestrator with provided middleware strategy and paths
+    const orchestrator = new ServiceOrchestrator({
+      interactive: options.interactive !== false,
+      outputPath: options.outputPath || '.',
+      templatePath: options.templatePath || './templates',
+      middlewareStrategy: options.middlewareStrategy || 'contract'
+    });
+
+    // If interactive mode requested (default), run interactive flow
+    if (options.interactive !== false) {
+      await orchestrator.runInteractive();
+      return {
+        success: true,
+        message: 'Service created (interactive)'
+      };
+    }
+
+    // Non-interactive flow: build core inputs and run non-interactive
+    const coreInputs = {
+      serviceName: options.name,
+      serviceType: options.type,
+      domainName: options.domain,
+      environment: options.environment || 'development',
+      cloudflareToken: options.credentials?.token,
+      cloudflareAccountId: options.credentials?.accountId,
+      cloudflareZoneId: options.credentials?.zoneId
+    };
+    await orchestrator.runNonInteractive(coreInputs);
+    return {
+      success: true,
+      message: `Service ${options.name} created`
+    };
   }
 
   /**