@tamyla/clodo-framework 3.1.12 → 3.1.13

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [3.1.13](https://github.com/tamylaa/clodo-framework/compare/v3.1.12...v3.1.13) (2025-10-27)
+
+
+### Bug Fixes
+
+* add comprehensive test coverage for service validation ([393e6d2](https://github.com/tamylaa/clodo-framework/commit/393e6d268348cc2926c80f0d3f6cd5377c2875a2))
+* add intelligent Cloudflare service detection and validation ([a680006](https://github.com/tamylaa/clodo-framework/commit/a6800063e2df8f8d6fa7660079cd22eb3f9a4a97))
+
 ## [3.1.12](https://github.com/tamylaa/clodo-framework/compare/v3.1.11...v3.1.12) (2025-10-27)
 
 

package/dist/bin/commands/deploy.js

@@ -2,46 +2,39 @@
  * Deploy Command - Smart minimal input deployment with service detection
  * 
  * Input Strategy: SMART MINIMAL
- * - Detects if project is a service (clodo-service-manifest.json)
- * - Gathers credentials smartly: env vars → flags → fail with helpful message (never prompt)
+ * - Detects Clodo services OR legacy services (wrangler.toml)
+ * - Supports multiple manifest locations
+ * - Gathers credentials smartly: env vars → flags → fail with helpful message
  * - Integrates with modular-enterprise-deploy.js for clean CLI-based deployment
  */
 
 import chalk from 'chalk';
-import { existsSync, readFileSync } from 'fs';
-import { resolve, join } from 'path';
+import { resolve } from 'path';
+import { ManifestLoader } from '../shared/config/manifest-loader.js';
+import { CloudflareServiceValidator } from '../shared/config/cloudflare-service-validator.js';
 export function registerDeployCommand(program) {
   program.command('deploy').description('Deploy a Clodo service with smart credential handling').option('--token <token>', 'Cloudflare API token').option('--account-id <id>', 'Cloudflare account ID').option('--zone-id <id>', 'Cloudflare zone ID').option('--dry-run', 'Simulate deployment without making changes').option('--quiet', 'Quiet mode - minimal output').option('--service-path <path>', 'Path to service directory', '.').action(async options => {
     try {
       console.log(chalk.cyan('\n🚀 Clodo Service Deployment\n'));
 
-      // Step 1: Detect if this is a service project
+      // Step 1: Load and validate service configuration
       const servicePath = resolve(options.servicePath);
-      const manifestPath = join(servicePath, 'clodo-service-manifest.json');
-      if (!existsSync(manifestPath)) {
-        console.error(chalk.red('❌ This is not a Clodo service project'));
-        console.error(chalk.yellow('\nExpected to find: clodo-service-manifest.json'));
-        console.error(chalk.cyan('\nAre you trying to deploy the framework itself?'));
-        console.error(chalk.white('The clodo-framework repository is a library, not deployable.'));
-        console.error(chalk.white('Create a service first: npx clodo-service create'));
+      const serviceConfig = await ManifestLoader.loadAndValidateCloudflareService(servicePath);
+      if (!serviceConfig.manifest) {
+        if (serviceConfig.error === 'NOT_A_CLOUDFLARE_SERVICE') {
+          ManifestLoader.printNotCloudflareServiceError(servicePath);
+        } else if (serviceConfig.error === 'CLOUDFLARE_SERVICE_INVALID') {
+          ManifestLoader.printValidationErrors(serviceConfig.validationResult);
+        }
         process.exit(1);
       }
 
-      // Read service manifest
-      let manifest;
-      try {
-        const manifestContent = readFileSync(manifestPath, 'utf8');
-        manifest = JSON.parse(manifestContent);
-      } catch (err) {
-        console.error(chalk.red('❌ Failed to read service manifest'));
-        console.error(chalk.yellow(`Error: ${err.message}`));
-        process.exit(1);
+      // Print service info and validation results
+      if (serviceConfig.validationResult) {
+        CloudflareServiceValidator.printValidationReport(serviceConfig.validationResult.validation);
       }
-      const serviceName = manifest.serviceName || 'unknown-service';
-      const serviceType = manifest.serviceType || 'unknown-type';
-      console.log(chalk.white(`Service: ${chalk.bold(serviceName)}`));
-      console.log(chalk.white(`Type: ${serviceType}`));
-      console.log(chalk.white(`Path: ${servicePath}\n`));
+      ManifestLoader.printManifestInfo(serviceConfig.manifest);
+      console.log(chalk.gray(`Configuration loaded from: ${serviceConfig.foundAt}\n`));
 
       // Step 2: Smart credential gathering
       // Priority: flags → environment variables → fail with helpful message
@@ -84,11 +77,12 @@ export function registerDeployCommand(program) {
       }
 
       // Step 3: Extract configuration from manifest
-      const config = manifest.configuration || {};
-      const domain = config.domain || config.domainName;
-      if (!domain) {
-        console.error(chalk.red('❌ No domain configured in service manifest'));
-        console.error(chalk.yellow('Update clodo-service-manifest.json with domain configuration'));
+      const manifest = serviceConfig.manifest;
+      const config = manifest.deployment || manifest.configuration || {};
+      const domains = config.domains || [];
+      if (domains.length === 0) {
+        console.error(chalk.red('❌ No domains configured in service manifest'));
+        console.error(chalk.yellow('Add domain configuration to: clodo-service-manifest.json'));
         process.exit(1);
       }
       console.log(chalk.cyan('📋 Deployment Plan:'));

package/dist/bin/shared/config/cloudflare-service-validator.js

@@ -0,0 +1,182 @@
+/**
+ * Cloudflare Service Validator
+ * 
+ * Validates that a directory is a properly formed Cloudflare Workers service
+ * and detects quality issues before deployment attempts
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import TOML from '@iarna/toml';
+export class CloudflareServiceValidator {
+  /**
+   * Check if directory has basic Cloudflare service signatures
+   * Returns: { isCloudflareService, wranglerPath, packagePath, errors }
+   */
+  static detectCloudflareService(servicePath) {
+    const wranglerPath = join(servicePath, 'wrangler.toml');
+    const packagePath = join(servicePath, 'package.json');
+    const hasWrangler = existsSync(wranglerPath);
+    const hasPackage = existsSync(packagePath);
+    const errors = [];
+    if (!hasWrangler) errors.push('Missing wrangler.toml');
+    if (!hasPackage) errors.push('Missing package.json');
+    return {
+      isCloudflareService: hasWrangler && hasPackage,
+      wranglerPath: hasWrangler ? wranglerPath : null,
+      packagePath: hasPackage ? packagePath : null,
+      errors
+    };
+  }
+
+  /**
+   * Validate service has proper entry points and structure
+   * Returns: { isValid, issues, warnings }
+   */
+  static validateServiceStructure(servicePath, wranglerPath, packagePath) {
+    const issues = [];
+    const warnings = [];
+    try {
+      // Parse files
+      const wranglerContent = readFileSync(wranglerPath, 'utf8');
+      const wranglerConfig = TOML.parse(wranglerContent);
+      const packageContent = readFileSync(packagePath, 'utf8');
+      const packageJson = JSON.parse(packageContent);
+
+      // Check wrangler.toml quality
+      if (!wranglerConfig.name) {
+        issues.push('wrangler.toml: Missing "name" field');
+      }
+      if (!wranglerConfig.main) {
+        warnings.push('wrangler.toml: No "main" entry point specified (will use default)');
+      }
+
+      // Check package.json quality
+      if (!packageJson.name) {
+        issues.push('package.json: Missing "name" field');
+      }
+      if (!packageJson.dependencies && !packageJson.devDependencies) {
+        warnings.push('package.json: No dependencies defined');
+      }
+
+      // Check for common entry points
+      const possibleEntryPoints = ['src/worker/index.js', 'src/index.js', 'index.js', 'dist/index.js', wranglerConfig.main].filter(Boolean);
+      const hasEntryPoint = possibleEntryPoints.some(ep => existsSync(join(servicePath, ep)));
+      if (!hasEntryPoint) {
+        warnings.push(`No recognizable entry point found. Checked: ${possibleEntryPoints.join(', ')}`);
+      }
+
+      // Check for Cloudflare environment
+      const env = wranglerConfig.env || {};
+      if (Object.keys(env).length === 0) {
+        warnings.push('wrangler.toml: No environments configured (production, staging, etc)');
+      }
+
+      // Check for routes configuration
+      const routes = wranglerConfig.routes;
+      if (!routes) {
+        warnings.push('wrangler.toml: No routes defined (service may not be accessible)');
+      }
+      return {
+        isValid: issues.length === 0,
+        issues,
+        warnings,
+        wranglerConfig,
+        packageJson
+      };
+    } catch (err) {
+      return {
+        isValid: false,
+        issues: [`Failed to parse config files: ${err.message}`],
+        warnings: [],
+        error: err
+      };
+    }
+  }
+
+  /**
+   * Check if service has existing deployment history
+   */
+  static detectExistingDeployments(servicePath) {
+    const possibleLocations = [join(servicePath, '.wrangler'), join(servicePath, 'dist'), join(servicePath, 'build'), join(servicePath, '.deployments')];
+    const existingDeployments = possibleLocations.filter(loc => existsSync(loc));
+    return {
+      hasDeploymentHistory: existingDeployments.length > 0,
+      deploymentMarkers: existingDeployments
+    };
+  }
+
+  /**
+   * Print validation report
+   */
+  static printValidationReport(validation) {
+    if (validation.issues.length > 0) {
+      console.error(chalk.red('\n❌ Service Configuration Issues:\n'));
+      validation.issues.forEach(issue => {
+        console.error(chalk.red(`  • ${issue}`));
+      });
+    }
+    if (validation.warnings.length > 0) {
+      console.warn(chalk.yellow('\n⚠️  Service Configuration Warnings:\n'));
+      validation.warnings.forEach(warning => {
+        console.warn(chalk.yellow(`  • ${warning}`));
+      });
+    }
+    if (validation.isValid && validation.warnings.length === 0) {
+      console.log(chalk.green('\n✅ Service structure looks good!\n'));
+    }
+  }
+
+  /**
+   * Interactive validation: ask user if they want to continue despite warnings
+   */
+  static async askContinueDespiteWarnings() {
+    // This would be called from interactive context
+    // For now, return a promise that can be used in async/await
+    return new Promise(resolve => {
+      // In actual implementation, would use readline or similar
+      // For this stub, we'll indicate the method exists
+      resolve(true);
+    });
+  }
+
+  /**
+   * Comprehensive service validation workflow
+   */
+  static validateForDeployment(servicePath) {
+    // Step 1: Check for basic signatures
+    const detection = this.detectCloudflareService(servicePath);
+    if (!detection.isCloudflareService) {
+      return {
+        canDeploy: false,
+        reason: 'NOT_A_CLOUDFLARE_SERVICE',
+        detection,
+        details: 'This directory does not have the required files for a Cloudflare Workers service.'
+      };
+    }
+
+    // Step 2: Validate structure
+    const validation = this.validateServiceStructure(servicePath, detection.wranglerPath, detection.packagePath);
+    if (!validation.isValid) {
+      return {
+        canDeploy: false,
+        reason: 'SERVICE_CONFIGURATION_INVALID',
+        validation,
+        details: 'The service configuration is invalid and may not deploy correctly.'
+      };
+    }
+
+    // Step 3: Check deployment history
+    const deploymentHistory = this.detectExistingDeployments(servicePath);
+    return {
+      canDeploy: true,
+      reason: validation.warnings.length > 0 ? 'SERVICE_VALID_WITH_WARNINGS' : 'SERVICE_VALID',
+      detection,
+      validation,
+      deploymentHistory,
+      details: 'Service is ready for deployment.'
+    };
+  }
+}
+export default CloudflareServiceValidator;

package/dist/bin/shared/config/manifest-loader.js

@@ -0,0 +1,287 @@
+/**
+ * Manifest Loader - Flexible service manifest detection and loading
+ * 
+ * Supports:
+ * - Clodo Framework generated manifests (service-manifest.json)
+ * - Legacy services (wrangler.toml + package.json)
+ * - Custom manifest locations
+ * - Environment variable overrides
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import chalk from 'chalk';
+import { CloudflareServiceValidator } from './cloudflare-service-validator.js';
+
+/**
+ * Possible manifest locations (in order of priority)
+ */
+const MANIFEST_LOCATIONS = ['clodo-service-manifest.json',
+// Standard location (root)
+'.clodo/service-manifest.json',
+// Hidden config directory
+'config/service-manifest.json' // Config subdirectory
+];
+
+/**
+ * Fallback configuration builders for legacy services
+ */
+class LegacyServiceDetector {
+  /**
+   * Build manifest-like config from wrangler.toml + package.json
+   */
+  static async buildFromWrangler(servicePath) {
+    const wranglerPath = join(servicePath, 'wrangler.toml');
+    const packagePath = join(servicePath, 'package.json');
+    if (!existsSync(wranglerPath) || !existsSync(packagePath)) {
+      return null;
+    }
+    try {
+      const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
+      return {
+        _source: 'legacy-wrangler',
+        _legacyNote: 'This is a legacy service without a service-manifest.json. Consider running: npx clodo-service init',
+        serviceName: packageJson.name || 'unknown-service',
+        serviceType: 'legacy-workers-project',
+        version: packageJson.version || '1.0.0',
+        isClodoService: false,
+        isLegacyService: true,
+        deployment: {
+          framework: 'wrangler',
+          ready: true,
+          configFiles: {
+            wrangler: './wrangler.toml',
+            package: './package.json'
+          }
+        },
+        metadata: {
+          detectedAt: new Date().toISOString(),
+          framework: 'legacy-wrangler'
+        }
+      };
+    } catch (err) {
+      return null;
+    }
+  }
+
+  /**
+   * Build manifest-like config from package.json alone
+   */
+  static async buildFromPackageJson(servicePath) {
+    const packagePath = join(servicePath, 'package.json');
+    if (!existsSync(packagePath)) {
+      return null;
+    }
+    try {
+      const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
+      return {
+        _source: 'legacy-package-only',
+        _legacyNote: 'This project has a package.json but no deployment configuration.',
+        serviceName: packageJson.name || 'unknown-service',
+        serviceType: 'nodejs-project',
+        version: packageJson.version || '1.0.0',
+        isClodoService: false,
+        isLegacyService: true,
+        deployment: {
+          framework: 'nodejs',
+          ready: false,
+          configFiles: {
+            package: './package.json'
+          }
+        },
+        metadata: {
+          detectedAt: new Date().toISOString(),
+          framework: 'legacy-nodejs'
+        }
+      };
+    } catch (err) {
+      return null;
+    }
+  }
+}
+
+/**
+ * Main manifest loader
+ */
+export class ManifestLoader {
+  /**
+   * Load service configuration with intelligent Cloudflare service validation
+   * 
+   * Returns:
+   * - Clodo Framework manifest (if found)
+   * - Validated Cloudflare service config (wrangler.toml + package.json)
+   * - Error details if not a valid Cloudflare service
+   */
+  static async loadAndValidateCloudflareService(servicePath = '.') {
+    const resolvedPath = resolve(servicePath);
+
+    // Step 1: Try loading Clodo manifest first
+    for (const location of MANIFEST_LOCATIONS) {
+      const manifestPath = join(resolvedPath, location);
+      if (existsSync(manifestPath)) {
+        try {
+          const content = readFileSync(manifestPath, 'utf8');
+          const manifest = JSON.parse(content);
+          manifest._source = 'clodo-manifest';
+          manifest._location = location;
+          manifest.isClodoService = true;
+          manifest.isValidCloudflareService = true;
+          return {
+            manifest,
+            foundAt: manifestPath,
+            isClodo: true,
+            validationResult: null
+          };
+        } catch (err) {
+          throw new Error(`Failed to parse manifest at ${manifestPath}: ${err.message}`);
+        }
+      }
+    }
+
+    // Step 2: Validate as Cloudflare service (requires wrangler.toml + package.json)
+    const validationResult = CloudflareServiceValidator.validateForDeployment(resolvedPath);
+    if (!validationResult.canDeploy && validationResult.reason === 'NOT_A_CLOUDFLARE_SERVICE') {
+      return {
+        manifest: null,
+        foundAt: null,
+        isClodo: false,
+        validationResult,
+        error: 'NOT_A_CLOUDFLARE_SERVICE'
+      };
+    }
+
+    // Step 3: Build manifest-like config from Cloudflare service
+    if (validationResult.canDeploy || validationResult.reason === 'SERVICE_VALID_WITH_WARNINGS') {
+      const manifest = this.buildFromCloudflareService(validationResult, resolvedPath);
+      return {
+        manifest,
+        foundAt: 'detected-cloudflare-service',
+        isClodo: false,
+        validationResult,
+        isValidCloudflareService: true
+      };
+    }
+
+    // Service is Cloudflare but has issues
+    return {
+      manifest: null,
+      foundAt: null,
+      isClodo: false,
+      validationResult,
+      error: 'CLOUDFLARE_SERVICE_INVALID'
+    };
+  }
+
+  /**
+   * Build manifest-like config from valid Cloudflare service files
+   */
+  static buildFromCloudflareService(validationResult, servicePath) {
+    const wranglerConfig = validationResult.validation.wranglerConfig;
+    const packageJson = validationResult.validation.packageJson;
+    return {
+      _source: 'cloudflare-service-detected',
+      _legacyNote: 'This is a Cloudflare Workers service. Consider creating it with: npx clodo-service create',
+      serviceName: packageJson.name || wranglerConfig.name || 'unknown-service',
+      serviceType: 'cloudflare-workers-service',
+      version: packageJson.version || '1.0.0',
+      isClodoService: false,
+      isValidCloudflareService: true,
+      deployment: {
+        framework: 'wrangler',
+        ready: validationResult.deploymentHistory.hasDeploymentHistory,
+        configFiles: {
+          wrangler: './wrangler.toml',
+          package: './package.json'
+        },
+        hasExistingDeployments: validationResult.deploymentHistory.hasDeploymentHistory
+      },
+      metadata: {
+        detectedAt: new Date().toISOString(),
+        framework: 'wrangler',
+        detectionReason: validationResult.reason
+      }
+    };
+  }
+
+  /**
+   * Print helpful error message for non-Cloudflare services
+   */
+  static printNotCloudflareServiceError(servicePath = '.') {
+    console.error(chalk.red('\n❌ Not a Cloudflare Workers Service\n'));
+    console.error(chalk.white('This directory is missing required Cloudflare files:'));
+    console.error(chalk.gray('  - wrangler.toml'));
+    console.error(chalk.gray('  - package.json'));
+    console.error(chalk.cyan('\n📋 To deploy, you need either:\n'));
+    console.error(chalk.white('Option 1: Create a new Clodo service'));
+    console.error(chalk.green('  npx clodo-service create'));
+    console.error(chalk.gray('  (Creates: service-manifest.json + full structure)\n'));
+    console.error(chalk.white('Option 2: Initialize an existing project'));
+    console.error(chalk.green('  npx clodo-service init'));
+    console.error(chalk.gray('  (Creates: service-manifest.json from existing files)\n'));
+    console.error(chalk.white('Option 3: Create a standard Cloudflare project'));
+    console.error(chalk.green('  npm init wrangler@latest'));
+    console.error(chalk.gray('  (Creates: wrangler.toml + package.json)\n'));
+  }
+
+  /**
+   * Print validation issues for malformed services
+   */
+  static printValidationErrors(validationResult) {
+    if (validationResult.validation.issues.length > 0) {
+      console.error(chalk.red('\n❌ Service Configuration Issues:\n'));
+      validationResult.validation.issues.forEach(issue => {
+        console.error(chalk.red(`  • ${issue}`));
+      });
+    }
+    if (validationResult.validation.warnings.length > 0) {
+      console.warn(chalk.yellow('\n⚠️  Service Configuration Warnings:\n'));
+      validationResult.validation.warnings.forEach(warning => {
+        console.warn(chalk.yellow(`  • ${warning}`));
+      });
+      console.warn(chalk.cyan('\nContinue with deployment? (May fail or behave unexpectedly)'));
+    }
+  }
+
+  /**
+   * Validate manifest has required fields for deployment
+   */
+  static validateDeploymentReady(manifest) {
+    const errors = [];
+
+    // Required for both Clodo and legacy services
+    if (!manifest.serviceName) errors.push('Missing: serviceName');
+    if (!manifest.deployment) errors.push('Missing: deployment configuration');
+
+    // For Clodo services
+    if (manifest.isClodoService) {
+      if (!manifest.deployment.domains || manifest.deployment.domains.length === 0) {
+        errors.push('Missing: deployment.domains (required for multi-domain deployment)');
+      }
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Print manifest info for debugging
+   */
+  static printManifestInfo(manifest) {
+    console.log(chalk.cyan('\n📋 Service Configuration:\n'));
+    console.log(chalk.white(`Service Name: ${chalk.bold(manifest.serviceName)}`));
+    console.log(chalk.white(`Service Type: ${chalk.bold(manifest.serviceType)}`));
+    console.log(chalk.white(`Source: ${chalk.gray(manifest._source)}`));
+    if (manifest._legacyNote) {
+      console.log(chalk.yellow(`\nℹ️  ${manifest._legacyNote}`));
+    }
+    if (manifest.deployment.domains) {
+      console.log(chalk.white(`\nDomains:`));
+      manifest.deployment.domains.forEach(domain => {
+        console.log(chalk.gray(`  - ${domain.name} (${domain.environment})`));
+      });
+    }
+    console.log('');
+  }
+}
+export default ManifestLoader;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamyla/clodo-framework",
-  "version": "3.1.12",
+  "version": "3.1.13",
   "description": "Reusable framework for Clodo-style software architecture on Cloudflare Workers + D1",
   "type": "module",
   "sideEffects": [