@tamyla/clodo-framework 4.0.7 → 4.0.10

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [4.0.10](https://github.com/tamylaa/clodo-framework/compare/v4.0.9...v4.0.10) (2025-12-10)
+
+
+### Bug Fixes
+
+* clean up test artifacts and temporary files ([0eb6cda](https://github.com/tamylaa/clodo-framework/commit/0eb6cdac68bce6d07e567f4b7810f4d94752b7c0))
+
+## [4.0.8](https://github.com/tamylaa/clodo-framework/compare/v4.0.7...v4.0.8) (2025-12-09)
+
+
+### Bug Fixes
+
+* respect user-provided worker and database names in deployment ([04ffc38](https://github.com/tamylaa/clodo-framework/commit/04ffc382ab910d4d260ba5c3f2e421763587948a))
+
 ## [4.0.7](https://github.com/tamylaa/clodo-framework/compare/v4.0.6...v4.0.7) (2025-12-09)
 
 

package/dist/cli/clodo-service.js

@@ -16,7 +16,11 @@
  * - list-types  List available service types and their features
  */
 import { Command } from 'commander';
+import { join, dirname } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
 import chalk from 'chalk';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
 // Create program instance
 const program = new Command();
@@ -25,33 +29,35 @@ program.name('clodo-service').description('Unified conversational CLI for Clodo
 // Dynamically load available command modules
 // This makes the CLI resilient if some commands are excluded from the package
 async function registerAvailableCommands() {
+  // Use absolute paths to ensure commands are found regardless of working directory
+  const commandsDir = join(__dirname, 'commands');
   const commands = [{
     name: 'create',
-    path: './commands/create.js',
+    path: pathToFileURL(join(commandsDir, 'create.js')).href,
     register: 'registerCreateCommand'
   }, {
     name: 'deploy',
-    path: './commands/deploy.js',
+    path: pathToFileURL(join(commandsDir, 'deploy.js')).href,
     register: 'registerDeployCommand'
   }, {
     name: 'validate',
-    path: './commands/validate.js',
+    path: pathToFileURL(join(commandsDir, 'validate.js')).href,
     register: 'registerValidateCommand'
   }, {
     name: 'update',
-    path: './commands/update.js',
+    path: pathToFileURL(join(commandsDir, 'update.js')).href,
     register: 'registerUpdateCommand'
   }, {
     name: 'diagnose',
-    path: './commands/diagnose.js',
+    path: pathToFileURL(join(commandsDir, 'diagnose.js')).href,
     register: 'registerDiagnoseCommand'
   }, {
     name: 'assess',
-    path: './commands/assess.js',
+    path: pathToFileURL(join(commandsDir, 'assess.js')).href,
     register: 'registerAssessCommand'
   }, {
     name: 'init-config',
-    path: './commands/init-config.js',
+    path: pathToFileURL(join(commandsDir, 'init-config.js')).href,
     register: 'registerInitConfigCommand'
   }];
   for (const cmd of commands) {

package/dist/cli/commands/init-config.js

@@ -5,14 +5,46 @@
  * Copies the framework's validation-config.json to the service directory for customization
  */
 import { copyFile, access } from 'fs/promises';
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import chalk from 'chalk';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-// Path to framework's bundled config
-const FRAMEWORK_CONFIG_PATH = join(__dirname, '../../config/validation-config.json');
+/**
+ * Find the framework's config directory by walking up from the current working directory
+ * or from the command file location
+ */
+export async function findFrameworkConfig() {
+  // First try relative to this command file
+  const relativeToCommand = join(__dirname, '../../config/validation-config.json');
+  try {
+    // Check if the file exists at the expected location
+    await access(relativeToCommand);
+    return relativeToCommand;
+  } catch {
+    // If not found, try to find it by walking up from current working directory
+    let currentDir = process.cwd();
+    const maxDepth = 10;
+    for (let i = 0; i < maxDepth; i++) {
+      const candidatePath = join(currentDir, 'config', 'validation-config.json');
+      try {
+        await access(candidatePath);
+        return candidatePath;
+      } catch {
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir) {
+          // Reached root directory
+          break;
+        }
+        currentDir = parentDir;
+      }
+    }
+
+    // As fallback, try absolute path from command location
+    return resolve(__dirname, '../../config/validation-config.json');
+  }
+}
 
 /**
  * Register the init-config command with the CLI
@@ -23,6 +55,9 @@ export function registerInitConfigCommand(program) {
 async function handler(options) {
   const targetPath = join(process.cwd(), 'validation-config.json');
   try {
+    // Find the framework config file
+    const frameworkConfigPath = await findFrameworkConfig();
+
     // Check if file already exists
     try {
       await access(targetPath);
@@ -38,7 +73,7 @@ async function handler(options) {
     }
 
     // Copy framework config to service directory
-    await copyFile(FRAMEWORK_CONFIG_PATH, targetPath);
+    await copyFile(frameworkConfigPath, targetPath);
     console.log(chalk.green('✅ Successfully initialized validation-config.json'));
     console.log(chalk.gray('\n📝 Configuration file details:'));
     console.log(chalk.gray(`   Location: ${targetPath}`));

package/dist/config/customers.js

@@ -38,9 +38,7 @@ export class CustomerConfigurationManager {
     const customerDir = resolve(this.configDir, 'customers', customerName);
 
     // Create customer directory structure
-    console.log(`DEBUG: Checking if directory exists: ${customerDir}`);
     if (!fs.existsSync(customerDir)) {
-      console.log(`DEBUG: Creating directory: ${customerDir}`);
       fs.mkdirSync(customerDir, {
         recursive: true
       });

package/dist/lib/shared/deployment/validator.js

@@ -598,9 +598,6 @@ export class DeploymentValidator {
   }
   async validateDomainEndpoints(domain) {
     console.log(`   Validating endpoints for ${domain}...`);
-    console.log(`   🔧 DEBUG: skipEndpointCheck = ${this.options?.skipEndpointCheck}`);
-    console.log(`   🔧 DEBUG: deploymentType = ${this.options?.deploymentType}`);
-    console.log(`   🔧 DEBUG: options = ${JSON.stringify(this.options)}`);
 
     // Skip endpoint validation for new deployments
     if (this.options?.skipEndpointCheck) {

package/dist/lib/shared/deployment/workflows/interactive-deployment-coordinator.js

@@ -214,6 +214,10 @@ export class InteractiveDeploymentCoordinator {
       environment: this.deploymentState.config.environment,
       domain: this.deploymentState.config.credentials.zoneName,
       serviceName: this.options.serviceName,
+      workerName: this.deploymentState.config.worker?.name,
+      // Pass the collected worker name
+      databaseName: this.deploymentState.resources.database?.name,
+      // Pass the collected database name
       dryRun: this.deploymentState.config.dryRun,
       credentials: this.deploymentState.config.credentials
     });

package/dist/orchestration/multi-domain-orchestrator.js

@@ -36,6 +36,8 @@ export class MultiDomainOrchestrator {
     this.parallelDeployments = options.parallelDeployments || 3;
     this.servicePath = options.servicePath || process.cwd();
     this.serviceName = options.serviceName || 'data-service'; // Service name for custom domain (e.g., 'data-service', 'auth-service')
+    this.workerName = options.workerName; // Specific worker name to use (optional)
+    this.databaseName = options.databaseName; // Specific database name to use (optional)
 
     // Wrangler config path - allows using customer-specific wrangler.toml files
     // If not specified, wrangler uses the default wrangler.toml in servicePath
@@ -293,13 +295,21 @@ export class MultiDomainOrchestrator {
   }
 
   /**
-   * Setup domain database using DatabaseOrchestrator
+   * Get base service name from worker name (remove environment suffixes)
+   * @returns {string} Base service name for URL generation
    */
+  getBaseServiceName() {
+    if (this.workerName) {
+      // Remove environment suffixes from worker name to get base service name
+      return this.workerName.replace(/-development$|-staging$|-production$/, '');
+    }
+    return this.serviceName || 'data-service';
+  }
   async setupDomainDatabase(domain) {
     console.log(`   🗄️ Setting up database for ${domain}`);
     if (this.dryRun) {
       console.log(`   � DRY RUN: Would create database for ${domain}`);
-      const databaseName = `${domain.replace(/\./g, '-')}-${this.environment}-db`;
+      const databaseName = this.databaseName || `${domain.replace(/\./g, '-')}-${this.environment}-db`;
       return {
         databaseName,
         databaseId: 'dry-run-id',
@@ -308,7 +318,8 @@ export class MultiDomainOrchestrator {
     }
     try {
       // Create D1 database using Cloudflare ops
-      const databaseName = `${domain.replace(/\./g, '-')}-${this.environment}-db`;
+      // Use provided database name, or generate one based on domain/environment
+      const databaseName = this.databaseName || `${domain.replace(/\./g, '-')}-${this.environment}-db`;
 
       // Check if database already exists
       console.log(`     � Checking if database exists: ${databaseName}`);
@@ -526,7 +537,7 @@ export class MultiDomainOrchestrator {
     if (this.dryRun) {
       console.log(`   🔍 DRY RUN: Would deploy worker for ${domain}`);
       // Use centralized domain template from validation-config.json
-      const customUrl = buildCustomDomain(this.serviceName, domain, this.environment);
+      const customUrl = buildCustomDomain(this.getBaseServiceName(), domain, this.environment);
       return {
         url: customUrl,
         deployed: false,
@@ -544,7 +555,8 @@ export class MultiDomainOrchestrator {
         // Generate or update customer config with current deployment parameters
         const customerConfigPath = await this.wranglerConfigManager.generateCustomerConfig(this.cloudflareZoneName, {
           accountId: this.cloudflareAccountId,
-          environment: this.environment
+          environment: this.environment,
+          workerName: this.workerName // Pass specific worker name if provided
         });
 
         // Copy customer config to root (ephemeral working copy for this deployment)
@@ -609,7 +621,7 @@ export class MultiDomainOrchestrator {
 
       // Construct custom domain URL using centralized template from validation-config.json
       // Handles all environment patterns: production, staging, development
-      const customUrl = buildCustomDomain(this.serviceName, domain, this.environment);
+      const customUrl = buildCustomDomain(this.getBaseServiceName(), domain, this.environment);
 
       // Store URLs in domain state
       const domainState = this.portfolioState.domainStates.get(domain);
@@ -621,6 +633,11 @@ export class MultiDomainOrchestrator {
         console.log(`   ✅ Worker deployed successfully`);
         console.log(`   🔗 Worker URL: ${workerUrl}`);
         console.log(`   🔗 Custom URL: ${customUrl}`);
+
+        // Display custom domain setup instructions
+        if (customUrl && workerUrl !== customUrl) {
+          this.displayCustomDomainInstructions(customUrl, workerUrl, domain);
+        }
       } else {
         console.log(`   ✅ Deployment completed (URL not detected in output)`);
         console.log(`   🔗 Expected URL: ${customUrl}`);
@@ -659,14 +676,22 @@ export class MultiDomainOrchestrator {
       return true;
     }
 
-    // Get the deployment URL from domain state
+    // Get the deployment URL from domain state - prefer worker URL for immediate validation
     const domainState = this.portfolioState.domainStates.get(domain);
-    const deploymentUrl = domainState?.deploymentUrl;
-    if (!deploymentUrl) {
+    const workerUrl = domainState?.workerUrl;
+    const customUrl = domainState?.deploymentUrl;
+
+    // Use worker URL for health check since it's immediately available after deployment
+    // Custom domain may require DNS configuration and won't work immediately
+    const healthCheckUrl = workerUrl || customUrl;
+    if (!healthCheckUrl) {
       console.log(`   ⚠️  No deployment URL found, skipping health check`);
       return true;
     }
-    console.log(`   🔍 Running health check: ${deploymentUrl}/health`);
+    console.log(`   🔍 Running health check: ${healthCheckUrl}/health`);
+    if (workerUrl && customUrl && workerUrl !== customUrl) {
+      console.log(`   ℹ️  Health check uses worker URL (custom domain requires DNS setup - see below)`);
+    }
 
     // Retry logic for health checks
     const maxRetries = 3;
@@ -678,7 +703,7 @@ export class MultiDomainOrchestrator {
         console.log(`   Attempt ${attempt}/${maxRetries}...`);
 
         // Perform actual HTTP health check
-        const response = await fetch(`${deploymentUrl}/health`, {
+        const response = await fetch(`${healthCheckUrl}/health`, {
           method: 'GET',
           headers: {
             'User-Agent': 'Clodo-Orchestrator/2.0'
@@ -692,7 +717,7 @@ export class MultiDomainOrchestrator {
 
           // Log successful health check
           this.stateManager.logAuditEvent('HEALTH_CHECK_PASSED', domain, {
-            url: deploymentUrl,
+            url: healthCheckUrl,
             status,
             responseTime,
             attempt,
@@ -703,7 +728,7 @@ export class MultiDomainOrchestrator {
           const errorMsg = `Health check returned ${status} - deployment may have issues`;
           console.log(`   ⚠️  ${errorMsg}`);
           this.stateManager.logAuditEvent('HEALTH_CHECK_WARNING', domain, {
-            url: deploymentUrl,
+            url: healthCheckUrl,
             status,
             responseTime,
             attempt,
@@ -718,9 +743,9 @@ export class MultiDomainOrchestrator {
         const errorMsg = `Health check failed: ${error.message}`;
         if (isLastAttempt) {
           console.log(`   ❌ ${errorMsg} (final attempt)`);
-          console.log(`   💡 The service may still be deploying. Check manually: curl ${deploymentUrl}/health`);
+          console.log(`   💡 The service may still be deploying. Check manually: curl ${healthCheckUrl}/health`);
           this.stateManager.logAuditEvent('HEALTH_CHECK_FAILED', domain, {
-            url: deploymentUrl,
+            url: healthCheckUrl,
             error: error.message,
             attempts: maxRetries,
             environment: this.environment
@@ -738,6 +763,43 @@ export class MultiDomainOrchestrator {
     return true;
   }
 
+  /**
+   * Display comprehensive custom domain setup instructions
+   * @param {string} customUrl - The custom domain URL
+   * @param {string} workerUrl - The worker URL to point DNS to
+   * @param {string} domain - The domain name
+   */
+  displayCustomDomainInstructions(customUrl, workerUrl, domain) {
+    console.log(`\n🌐 Custom Domain Setup Instructions`);
+    console.log(`═`.repeat(50));
+    console.log(`Your service is deployed and working at: ${workerUrl}`);
+    console.log(`To use your custom domain ${customUrl}, follow these steps:\n`);
+    console.log(`📋 Step 1: DNS Configuration`);
+    console.log(`   Create a CNAME record in your DNS settings:`);
+    // Extract subdomain from custom URL (everything before the domain)
+    const urlObj = new URL(customUrl);
+    const subdomain = urlObj.hostname.replace(`.${domain}`, '');
+    console.log(`   • Name: ${subdomain}`);
+    console.log(`   • Type: CNAME`);
+    console.log(`   • Target: ${workerUrl.replace('https://', '')}`);
+    console.log(`   • TTL: 300 (5 minutes)\n`);
+    console.log(`🔧 Step 2: Cloudflare Workers Configuration`);
+    console.log(`   1. Go to Cloudflare Dashboard → Workers & Pages`);
+    console.log(`   2. Select your worker`);
+    console.log(`   3. Go to "Triggers" tab`);
+    console.log(`   4. Click "Add Custom Domain"`);
+    console.log(`   5. Enter: ${customUrl}\n`);
+    console.log(`⏱️  Step 3: Wait for Propagation`);
+    console.log(`   • DNS changes: 5-30 minutes`);
+    console.log(`   • SSL certificate: 5-10 minutes`);
+    console.log(`   • Total setup time: 10-60 minutes\n`);
+    console.log(`✅ Step 4: Verify Setup`);
+    console.log(`   Test your custom domain:`);
+    console.log(`   curl -v ${customUrl}/health\n`);
+    console.log(`💡 Note: Your service is fully functional at the worker URL immediately.`);
+    console.log(`   The custom domain is optional for branding/user experience.\n`);
+  }
+
   /**
    * Get rollback plan using state manager
    * @returns {Array} Rollback plan from state manager
@@ -763,12 +825,14 @@ export class MultiDomainOrchestrator {
   }
 
   /**
-   * Simple API: Deploy a service with minimal configuration
-   * @param {Object} options - Simple deployment options
+   * Deploy a single service to a specific domain/environment
+   * @param {Object} options - Deployment options
    * @param {string} options.servicePath - Path to service directory
    * @param {string} options.environment - Target environment
    * @param {string} options.domain - Specific domain to deploy to (used as zone name and domain suffix)
    * @param {string} options.serviceName - Service name for URL generation (e.g., 'data-service', 'auth-service')
+   * @param {string} options.workerName - Specific worker name to use
+   * @param {string} options.databaseName - Specific database name to use
    * @param {boolean} options.dryRun - Simulate deployment
    * @param {Object} options.credentials - Cloudflare credentials
    * @returns {Promise<Object>} Deployment result
@@ -779,6 +843,8 @@ export class MultiDomainOrchestrator {
       environment = 'production',
       domain,
       serviceName,
+      workerName,
+      databaseName,
       dryRun = false,
       credentials = {}
     } = options;
@@ -790,6 +856,10 @@ export class MultiDomainOrchestrator {
       servicePath,
       serviceName,
       // Pass through serviceName if provided
+      workerName,
+      // Pass through workerName if provided
+      databaseName,
+      // Pass through databaseName if provided
       cloudflareToken: credentials.token,
       cloudflareAccountId: credentials.accountId,
       cloudflareZoneId: credentials.zoneId,

package/dist/simple-api.js

@@ -34,6 +34,9 @@ export class Clodo {
    * @param {string} options.servicePath - Path to service directory
    * @param {string} options.environment - Target environment
    * @param {string} options.domain - Specific domain to deploy to
+   * @param {string} options.serviceName - Service name for URL generation
+   * @param {string} options.workerName - Specific worker name to use
+   * @param {string} options.databaseName - Specific database name to use
    * @param {boolean} options.dryRun - Simulate deployment
    * @returns {Promise<Object>} Deployment result
    */

package/dist/utils/deployment/wrangler-config-manager.js

@@ -127,12 +127,14 @@ export class WranglerConfigManager {
    * @param {Object} params - Deployment parameters
    * @param {string} params.accountId - Cloudflare account ID
    * @param {string} params.environment - Deployment environment (production, staging, development)
+   * @param {string} params.workerName - Specific worker name to use (optional, overrides automatic naming)
    * @returns {Promise<string>} Path to generated/updated customer config
    */
   async generateCustomerConfig(zoneName, params = {}) {
     const {
       accountId,
-      environment = 'production'
+      environment = 'production',
+      workerName
     } = params;
     if (!zoneName) {
       throw new Error('Zone name is required to generate customer config');
@@ -186,16 +188,24 @@ export class WranglerConfigManager {
       console.log(`   ✅ Set account_id to ${accountId} in customer config`);
     }
 
-    // Update worker name based on zone
+    // Update worker name based on zone or provided name
     // Extract base service name and apply zone-based naming
     const customerPrefix = zoneName.split('.')[0]; // clodo.dev → clodo
 
     // Update root-level worker name
     if (config.name) {
-      const baseName = config.name.replace(/^[^-]+-/, ''); // Remove existing prefix
-      const newWorkerName = `${customerPrefix}-${baseName}`;
+      let newWorkerName;
+      if (workerName) {
+        // Use the provided worker name directly
+        newWorkerName = workerName;
+        console.log(`   ✅ Set worker name to ${newWorkerName} in customer config (provided)`);
+      } else {
+        // Apply automatic zone-based naming
+        const baseName = config.name.replace(/^[^-]+-/, ''); // Remove existing prefix
+        newWorkerName = `${customerPrefix}-${baseName}`;
+        console.log(`   ✅ Set worker name to ${newWorkerName} in customer config (auto-generated)`);
+      }
       config.name = newWorkerName;
-      console.log(`   ✅ Set worker name to ${newWorkerName} in customer config`);
     }
 
     // Update SERVICE_DOMAIN in environment variables (all environments)
@@ -227,9 +237,20 @@ export class WranglerConfigManager {
     if (config.env) {
       for (const [envName, envConfig] of Object.entries(config.env)) {
         if (envConfig.name) {
-          const baseName = envConfig.name.replace(/^[^-]+-/, ''); // Remove existing prefix
-          envConfig.name = `${customerPrefix}-${baseName}`;
-          console.log(`   ✅ Set [env.${envName}] worker name to ${envConfig.name}`);
+          let newEnvWorkerName;
+          if (workerName) {
+            // Derive environment-specific name from provided worker name
+            const baseName = workerName.replace(/-service$/, ''); // Remove -service suffix if present
+            const envSuffix = envName === 'production' ? '' : `-${envName}`;
+            newEnvWorkerName = `${baseName}${envSuffix}`;
+            console.log(`   ✅ Set [env.${envName}] worker name to ${newEnvWorkerName} (derived from provided name)`);
+          } else {
+            // Apply automatic zone-based naming
+            const baseName = envConfig.name.replace(/^[^-]+-/, ''); // Remove existing prefix
+            newEnvWorkerName = `${customerPrefix}-${baseName}`;
+            console.log(`   ✅ Set [env.${envName}] worker name to ${newEnvWorkerName} (auto-generated)`);
+          }
+          envConfig.name = newEnvWorkerName;
         }
         if (envConfig.vars) {
           updateServiceDomain(envConfig.vars);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamyla/clodo-framework",
-  "version": "4.0.7",
+  "version": "4.0.10",
   "description": "Reusable framework for Clodo-style software architecture on Cloudflare Workers + D1",
   "type": "module",
   "sideEffects": [
@@ -172,7 +172,7 @@
   "bugs": {
     "url": "https://github.com/tamylaa/clodo-framework/issues"
   },
-  "homepage": "https://clodo-framework.tamyla.com",
+  "homepage": "https://clodo.dev",
   "release": {
     "branches": [
       "main",