@tamyla/clodo-framework 4.0.2 → 4.0.4

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [4.0.4](https://github.com/tamylaa/clodo-framework/compare/v4.0.3...v4.0.4) (2025-12-08)
+
+
+### Bug Fixes
+
+* enhance existing resource handling and API token propagation ([c7b3a22](https://github.com/tamylaa/clodo-framework/commit/c7b3a226b01609f01f6e8cb1cf27b957cd11868e))
+
+## [4.0.3](https://github.com/tamylaa/clodo-framework/compare/v4.0.2...v4.0.3) (2025-12-08)
+
+
+### Bug Fixes
+
+* Export CLI utilities to enable framework CLI commands ([35f1701](https://github.com/tamylaa/clodo-framework/commit/35f1701653ebe01b8fe41d184d2b88dac4c5b8d4))
+
 ## [4.0.2](https://github.com/tamylaa/clodo-framework/compare/v4.0.1...v4.0.2) (2025-12-08)
 
 

package/dist/database/database-orchestrator.js

@@ -682,6 +682,11 @@ export class DatabaseOrchestrator {
     } else {
       command += ` --local`;
     }
+
+    // Add API token if available
+    if (this.cloudflareToken) {
+      command = `CLOUDFLARE_API_TOKEN=${this.cloudflareToken} ${command}`;
+    }
     return command;
   }
   buildBackupCommand(databaseName, environment, backupFile, isRemote) {

package/dist/lib/database/deployment-db-manager.js

@@ -200,10 +200,10 @@ export class DeploymentDatabaseManager {
   /**
    * Run database migrations
    */
-  async runDatabaseMigrations(config) {
+  async runDatabaseMigrations(config, credentials = {}) {
     console.log('\n🔄 Running database migrations...');
     try {
-      await runMigrations(config.database.name);
+      await runMigrations(config.database.name, 'production', credentials);
       console.log('   ✅ Database migrations completed');
       this.state.migrationsRun = true;
     } catch (error) {

package/dist/lib/shared/cloudflare/ops.js

@@ -154,11 +154,28 @@ export async function getCloudflareToken(requiredPermissions = ['api_access']) {
   }
   throw new Error('No valid Cloudflare API token found with required permissions');
 }
-export async function listWorkers() {
+export async function listWorkers(options = {}) {
+  const {
+    apiToken,
+    accountId
+  } = options;
+
+  // Use API-based operation if credentials provided
+  if (apiToken && accountId) {
+    const {
+      CloudflareAPI
+    } = await import('@tamyla/clodo-framework/utils/cloudflare');
+    const cf = new CloudflareAPI(apiToken);
+    return await cf.listWorkers(accountId);
+  }
+
+  // Fallback to CLI-based operation
   try {
+    const envVars = apiToken ? `CLOUDFLARE_API_TOKEN=${apiToken}` : '';
+    const command = `${envVars} npx wrangler list`;
     const {
       stdout: list
-    } = await executeWithRateLimit('npx wrangler list', 'workers');
+    } = await executeWithRateLimit(command, 'workers');
     return list;
   } catch (error) {
     throw new Error(`Failed to list workers: ${error.message}`);
@@ -207,26 +224,57 @@ export async function deployWorker(env = 'production') {
     throw new Error(`Worker deployment failed after retries: ${error.message}`);
   }
 }
-export async function deploySecret(key, value, env = 'production') {
-  const command = process.platform === 'win32' ? `powershell -Command "Write-Output '${value}' | npx wrangler secret put ${key} --env ${env}"` : `echo "${value}" | npx wrangler secret put ${key} --env ${env}`;
+export async function deploySecret(key, value, env = 'production', options = {}) {
+  const {
+    apiToken,
+    accountId,
+    scriptName
+  } = options;
+
+  // Use API-based operation if credentials provided
+  if (apiToken && accountId && scriptName) {
+    const {
+      CloudflareAPI
+    } = await import('@tamyla/clodo-framework/utils/cloudflare');
+    const cf = new CloudflareAPI(apiToken);
+    await cf.putWorkerSecret(accountId, scriptName, key, {
+      text: value
+    });
+    return;
+  }
+
+  // Fallback to CLI-based operation with API token if available
+  const envVars = apiToken ? `CLOUDFLARE_API_TOKEN=${apiToken}` : '';
+  const command = process.platform === 'win32' ? `${envVars} powershell -Command "Write-Output '${value}' | npx wrangler secret put ${key} --env ${env}"` : `${envVars} echo "${value}" | npx wrangler secret put ${key} --env ${env}`;
   try {
-    await executeWithRateLimit(command, 'workers', 3); // Lower retries for secrets
+    // Increase retries for secrets due to higher timeout likelihood
+    await executeWithRateLimit(command, 'workers', 5);
   } catch (error) {
     throw new Error(`Secret deployment failed: ${error.message}`);
   }
 }
-export async function deleteSecret(key, env = 'production') {
+export async function deleteSecret(key, env = 'production', options = {}) {
+  const {
+    apiToken
+  } = options;
+  const envVars = apiToken ? `CLOUDFLARE_API_TOKEN=${apiToken}` : '';
+  const command = `${envVars} npx wrangler secret delete ${key} --env ${env}`;
   try {
-    await executeWithRateLimit(`npx wrangler secret delete ${key} --env ${env}`, 'workers');
+    await executeWithRateLimit(command, 'workers');
   } catch (error) {
     throw new Error(`Secret deletion failed: ${error.message}`);
   }
 }
-export async function listSecrets(env = 'production') {
+export async function listSecrets(env = 'production', options = {}) {
+  const {
+    apiToken
+  } = options;
+  const envVars = apiToken ? `CLOUDFLARE_API_TOKEN=${apiToken}` : '';
+  const command = `${envVars} npx wrangler secret list --env ${env}`;
   try {
     const {
       stdout: list
-    } = await executeWithRateLimit(`npx wrangler secret list --env ${env}`, 'workers');
+    } = await executeWithRateLimit(command, 'workers');
     return list;
   } catch (error) {
     throw new Error(`Failed to list secrets: ${error.message}`);
@@ -298,9 +346,11 @@ export async function createDatabase(name, options = {}) {
 
   // Fallback to CLI-based operation
   try {
+    const envVars = apiToken ? `CLOUDFLARE_API_TOKEN=${apiToken}` : '';
+    const command = `${envVars} npx wrangler d1 create ${name}`;
     const {
       stdout: output
-    } = await executeWithRateLimit(`npx wrangler d1 create ${name}`, 'd1');
+    } = await executeWithRateLimit(command, 'd1');
     const idMatch = output.match(/database_id = "([^"]+)"/);
     if (!idMatch) {
       throw new Error('Could not extract database ID from creation output');
@@ -310,19 +360,29 @@ export async function createDatabase(name, options = {}) {
     throw new Error(`Database creation failed: ${error.message}`);
   }
 }
-export async function deleteDatabase(name) {
+export async function deleteDatabase(name, options = {}) {
+  const {
+    apiToken
+  } = options;
+  const envVars = apiToken ? `CLOUDFLARE_API_TOKEN=${apiToken}` : '';
+  const command = `${envVars} npx wrangler d1 delete ${name} --skip-confirmation`;
   try {
-    await executeWithRateLimit(`npx wrangler d1 delete ${name} --skip-confirmation`, 'd1');
+    await executeWithRateLimit(command, 'd1');
   } catch (error) {
     throw new Error(`Database deletion failed: ${error.message}`);
   }
 }
-export async function runMigrations(databaseName, env = 'production') {
+export async function runMigrations(databaseName, env = 'production', options = {}) {
+  const {
+    apiToken
+  } = options;
   const startTime = Date.now();
   try {
     await ensureMonitoringInitialized();
     const result = await errorRecovery.executeWithRecovery(async () => {
-      await executeWithRateLimit(`npx wrangler d1 migrations apply ${databaseName} --env ${env} --remote`, 'd1');
+      const envVars = apiToken ? `CLOUDFLARE_API_TOKEN=${apiToken}` : '';
+      const command = `${envVars} npx wrangler d1 migrations apply ${databaseName} --env ${env} --remote`;
+      await executeWithRateLimit(command, 'd1');
       return true;
     }, {
       operationId: `runMigrations_${databaseName}_${env}`

package/dist/lib/shared/deployment/workflows/interactive-database-workflow.js

@@ -21,9 +21,11 @@ export class InteractiveDatabaseWorkflow {
   /**
    * @param {Object} options - Configuration options
    * @param {Array} options.rollbackActions - Array to track rollback actions
+   * @param {boolean} options.dryRun - Dry run mode
    */
   constructor(options = {}) {
     this.rollbackActions = options.rollbackActions || [];
+    this.dryRun = options.dryRun || false;
   }
 
   /**
@@ -49,9 +51,15 @@ export class InteractiveDatabaseWorkflow {
     const databaseName = await this.promptForDatabaseName(suggestedName, options.interactive);
 
     // Check if database exists
-    const existingInfo = await this.checkExistingDatabase(databaseName);
+    const existingInfo = await this.checkExistingDatabase(databaseName, {
+      apiToken: options.apiToken,
+      accountId: options.accountId
+    });
     if (existingInfo.exists) {
-      return await this.handleExistingDatabase(databaseName, existingInfo, options.interactive);
+      return await this.handleExistingDatabase(databaseName, existingInfo, options.interactive, {
+        apiToken: options.apiToken,
+        accountId: options.accountId
+      });
     } else {
       return await this.createNewDatabase(databaseName, options.interactive, {
         apiToken: options.apiToken,
@@ -85,16 +93,36 @@ export class InteractiveDatabaseWorkflow {
    * @param {string} name - Database name
    * @returns {Promise<Object>} { exists: boolean, id?: string, error?: string }
    */
-  async checkExistingDatabase(name) {
+  async checkExistingDatabase(name, credentials = {}) {
     console.log('\n🔍 Checking for existing database...');
     try {
-      const exists = await databaseExists(name);
+      const exists = await databaseExists(name, credentials);
       if (exists) {
         console.log(`   📋 Database '${name}' already exists`);
 
-        // Extract database ID from the list command
+        // If using API, get the database ID from API
+        if (credentials.apiToken && credentials.accountId) {
+          try {
+            const {
+              CloudflareAPI
+            } = await import('@tamyla/clodo-framework/utils/cloudflare');
+            const cf = new CloudflareAPI(credentials.apiToken);
+            const dbInfo = await cf.getD1Database(credentials.accountId, name);
+            return {
+              exists: true,
+              id: dbInfo.uuid
+            };
+          } catch (apiError) {
+            console.log(`   ⚠️  Could not get database ID from API: ${apiError.message}`);
+            // Fall back to CLI method for ID extraction
+          }
+        }
+
+        // Extract database ID from the CLI list command (fallback)
         try {
-          const dbListResult = await execAsync('npx wrangler d1 list');
+          const envVars = credentials.apiToken ? `CLOUDFLARE_API_TOKEN=${credentials.apiToken}` : '';
+          const command = `${envVars} npx wrangler d1 list`;
+          const dbListResult = await execAsync(command);
           const lines = dbListResult.stdout.split('\n');
           for (const line of lines) {
             if (line.includes(name)) {
@@ -107,11 +135,14 @@ export class InteractiveDatabaseWorkflow {
               }
             }
           }
-        } catch (error) {
-          console.log('   ⚠️ Could not extract database ID');
+        } catch (cliError) {
+          console.log(`   ⚠️  Could not extract database ID: ${cliError.message}`);
         }
+
+        // Return exists=true but no ID if we can't get it
         return {
-          exists: true
+          exists: true,
+          id: null
         };
       } else {
         console.log(`   ✅ Database '${name}' does not exist`);
@@ -120,10 +151,10 @@ export class InteractiveDatabaseWorkflow {
         };
       }
     } catch (error) {
-      console.log('   ⚠️ Could not check existing databases');
+      console.log(`   ⚠️  Error checking database existence: ${error.message}`);
+      console.log('   ℹ️  Assuming database does not exist');
       return {
-        exists: false,
-        error: error.message
+        exists: false
       };
     }
   }
@@ -134,9 +165,10 @@ export class InteractiveDatabaseWorkflow {
    * @param {string} name - Database name
    * @param {Object} existingInfo - Information about existing database
    * @param {boolean} interactive - Enable interactive prompts
+   * @param {Object} credentials - Cloudflare API credentials
    * @returns {Promise<Object>} Database configuration
    */
-  async handleExistingDatabase(name, existingInfo, interactive = true) {
+  async handleExistingDatabase(name, existingInfo, interactive = true, credentials = {}) {
     if (!interactive) {
       // Non-interactive mode: reuse existing
       console.log(`   ✅ Using existing database: ${name}`);
@@ -176,7 +208,7 @@ export class InteractiveDatabaseWorkflow {
             throw new Error('Database deletion cancelled');
           }
           console.log(`\n🗑️ Deleting existing database...`);
-          await deleteDatabase(name);
+          await deleteDatabase(name, credentials);
           return await this.createNewDatabase(name, interactive);
         }
       default:
@@ -197,6 +229,18 @@ export class InteractiveDatabaseWorkflow {
   async createNewDatabase(name, interactive = true, credentials = {}) {
     console.log(`\n🆕 Creating new database: ${name}`);
 
+    // Check dry-run mode
+    if (this.dryRun) {
+      console.log('   🔍 DRY RUN: Would create database but skipping actual creation');
+      return {
+        name,
+        id: 'dry-run-database-id',
+        created: false,
+        reused: false,
+        dryRun: true
+      };
+    }
+
     // Log which method will be used
     if (credentials.apiToken && credentials.accountId) {
       console.log('   ℹ️  Using Cloudflare API for database creation');

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

@@ -68,10 +68,13 @@ export class InteractiveDeploymentCoordinator {
         configCache: null // TODO: Add config cache if available
       }),
       databaseWorkflow: new InteractiveDatabaseWorkflow({
-        interactive: true
+        interactive: true,
+        dryRun: this.options.dryRun
       }),
       secretWorkflow: new InteractiveSecretWorkflow({
-        interactive: true
+        interactive: true,
+        dryRun: this.options.dryRun,
+        credentials: this.options.credentials
       }),
       validation: new InteractiveValidationWorkflow({
         interactive: true
@@ -170,9 +173,10 @@ export class InteractiveDeploymentCoordinator {
   async configureSecrets() {
     console.log('🔐 Phase 3: Configuring Secrets & Credentials');
     console.log('─'.repeat(50));
-    const workerName = `${this.deploymentState.config.domain}-data-service`;
+    const workerName = this.deploymentState.config.worker?.name || `${this.deploymentState.config.domain}-data-service`;
     this.deploymentState.resources.secrets = await this.workflows.secretWorkflow.handleSecretManagement(this.deploymentState.config.domain, this.deploymentState.config.environment, workerName, {
-      interactive: true
+      interactive: true,
+      credentials: this.deploymentState.config.credentials
     });
     console.log('✅ Secrets configuration complete\n');
   }

package/dist/lib/shared/deployment/workflows/interactive-domain-info-gatherer.js

@@ -92,7 +92,10 @@ export class InteractiveDomainInfoGatherer {
     // Generate default worker configuration
     config.worker = config.worker || {};
     config.worker.name = `${config.domain}-data-service`;
-    config.worker.url = `https://${config.worker.name}.tamylatrading.workers.dev`;
+
+    // Use actual zone name from credentials if available, otherwise fallback
+    const zoneName = config.credentials?.zoneName || 'tamylatrading.workers.dev';
+    config.worker.url = `https://${config.worker.name}.${zoneName}`;
     console.log(`\n🔧 Generated Configuration:`);
     console.log(`   Worker Name: ${config.worker.name}`);
     console.log(`   Worker URL: ${config.worker.url}`);
@@ -101,8 +104,18 @@ export class InteractiveDomainInfoGatherer {
     }
     const confirmWorkerConfig = await askYesNo('Is this worker configuration correct?', 'y');
     if (!confirmWorkerConfig) {
-      config.worker.name = await askUser('Enter custom worker name', config.worker.name);
-      config.worker.url = `https://${config.worker.name}.tamylatrading.workers.dev`;
+      let customWorkerName = await askUser('Enter custom worker name', config.worker.name);
+
+      // Validate worker name - should not be a full URL
+      if (customWorkerName.includes('.') || customWorkerName.includes('/') || customWorkerName.includes('://')) {
+        console.log('   ⚠️  Worker name should be just the name, not a full URL');
+        console.log('   💡 Example: "my-service" not "my-service.workers.dev"');
+        customWorkerName = customWorkerName.split('.')[0]; // Extract just the first part
+        console.log(`   🔧 Using extracted name: ${customWorkerName}`);
+      }
+      config.worker.name = customWorkerName;
+      const zoneName = config.credentials?.zoneName || 'tamylatrading.workers.dev';
+      config.worker.url = `https://${config.worker.name}.${zoneName}`;
       console.log(`\n✅ Updated worker configuration`);
     }
   }

package/dist/lib/shared/deployment/workflows/interactive-secret-workflow.js

@@ -21,9 +21,13 @@ export class InteractiveSecretWorkflow {
   /**
    * @param {Object} options - Configuration options
    * @param {Array} options.rollbackActions - Array to track rollback actions
+   * @param {boolean} options.dryRun - Dry run mode
+   * @param {Object} options.credentials - Cloudflare credentials
    */
   constructor(options = {}) {
     this.rollbackActions = options.rollbackActions || [];
+    this.dryRun = options.dryRun || false;
+    this.credentials = options.credentials || {};
   }
 
   /**
@@ -161,6 +165,12 @@ export class InteractiveSecretWorkflow {
    */
   async deploySecrets(secrets, workerName, environment, interactive = true) {
     console.log('\n☁️ Deploying secrets to Cloudflare Workers...');
+
+    // Check dry-run mode
+    if (this.dryRun) {
+      console.log(`   🔍 DRY RUN: Would deploy ${Object.keys(secrets).length} secrets to worker '${workerName}' but skipping actual deployment`);
+      return;
+    }
     if (interactive) {
       const deployConfirmed = await askYesNo(`Deploy ${Object.keys(secrets).length} secrets to worker '${workerName}'?`, 'y');
       if (!deployConfirmed) {
@@ -170,7 +180,11 @@ export class InteractiveSecretWorkflow {
     for (const [key, value] of Object.entries(secrets)) {
       console.log(`   🔑 Deploying ${key}...`);
       try {
-        await deploySecret(key, value, environment);
+        await deploySecret(key, value, environment, {
+          apiToken: this.credentials?.token,
+          accountId: this.credentials?.accountId,
+          scriptName: workerName
+        });
         console.log(`      ✅ ${key} deployed`);
 
         // Add to rollback actions

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

@@ -35,8 +35,8 @@ export class InteractiveValidationWorkflow {
     // Check prerequisites
     await this.validatePrerequisites();
 
-    // Check authentication
-    await this.validateAuthentication();
+    // Check authentication - pass existing credentials if available
+    await this.validateAuthentication(config);
 
     // Check for existing deployments
     await this.checkExistingDeployments(config);
@@ -68,9 +68,16 @@ export class InteractiveValidationWorkflow {
   /**
    * Validate Cloudflare authentication
    * 
+   * @param {Object} config - Deployment configuration with credentials
    * @returns {Promise<void>}
    */
-  async validateAuthentication() {
+  async validateAuthentication(config = {}) {
+    // If credentials are already collected, skip authentication check
+    if (config.credentials?.token && config.credentials?.accountId) {
+      console.log('\n🔐 Using collected Cloudflare credentials...');
+      console.log('✅ Authentication validated via deployment workflow');
+      return;
+    }
     console.log('\n🔐 Checking Cloudflare authentication...');
     const isAuthenticated = await checkAuth();
     if (!isAuthenticated) {
@@ -104,17 +111,144 @@ export class InteractiveValidationWorkflow {
         console.log('   ℹ️  Non-interactive mode: will overwrite existing worker');
         return true;
       }
-      const shouldOverwrite = await askYesNo('Do you want to overwrite the existing worker?', 'n');
-      if (!shouldOverwrite) {
-        throw new Error('Deployment cancelled - worker already exists');
-      }
-      return true;
+      return await this.handleExistingWorker(config);
     } else {
       console.log(`   ✅ Worker name '${config.worker.name}' is available`);
       return false;
     }
   }
 
+  /**
+   * Handle existing worker with multiple options
+   *
+   * @param {Object} config - Deployment configuration
+   * @returns {Promise<boolean>} True if deployment should proceed
+   */
+  async handleExistingWorker(config) {
+    console.log('\n🔄 Existing Worker Options:');
+    console.log('===========================');
+    const {
+      askChoice
+    } = await import('../utils/prompt-utils.js');
+    const choice = await askChoice('How would you like to handle the existing worker?', ['🔄 Overwrite/Update - Deploy new version (recommended)', '📝 Rename - Create with a different worker name', '🔍 Compare - Show differences before deciding', '💾 Backup & Update - Create backup before overwriting', '❌ Cancel - Stop deployment'], 0);
+    switch (choice) {
+      case 0:
+        // Overwrite/Update
+        console.log('   ✅ Will overwrite existing worker with new deployment');
+        return true;
+      case 1:
+        // Rename
+        const newName = await this.promptForNewWorkerName(config.worker.name);
+        config.worker.name = newName;
+        config.worker.url = `https://${newName}.${config.credentials?.zoneName || 'tamylatrading.workers.dev'}`;
+        console.log(`   ✅ Will deploy as new worker: ${newName}`);
+        return true;
+      case 2:
+        // Compare
+        await this.compareExistingWorker(config);
+        // After comparison, ask again
+        return await this.handleExistingWorker(config);
+      case 3:
+        // Backup & Update
+        await this.backupExistingWorker(config);
+        console.log('   ✅ Backup created, will now overwrite existing worker');
+        return true;
+      case 4: // Cancel
+      default:
+        throw new Error('Deployment cancelled by user');
+    }
+  }
+
+  /**
+   * Prompt for a new worker name
+   *
+   * @param {string} currentName - Current worker name
+   * @returns {Promise<string>} New worker name
+   */
+  async promptForNewWorkerName(currentName) {
+    const {
+      askUser
+    } = await import('../utils/prompt-utils.js');
+    let newName = await askUser(`Enter new worker name (current: ${currentName})`);
+    newName = newName.trim();
+    if (!newName) {
+      throw new Error('Worker name cannot be empty');
+    }
+
+    // Basic validation
+    if (newName.length < 3) {
+      throw new Error('Worker name must be at least 3 characters long');
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(newName)) {
+      throw new Error('Worker name can only contain letters, numbers, hyphens, and underscores');
+    }
+
+    // Check if the new name also exists
+    const exists = await workerExists(newName);
+    if (exists) {
+      console.log(`   ⚠️ Worker '${newName}' also exists!`);
+      const useAnyway = await askUser('Use this name anyway? (y/n)', 'n');
+      if (useAnyway.toLowerCase() !== 'y' && useAnyway.toLowerCase() !== 'yes') {
+        return await this.promptForNewWorkerName(currentName);
+      }
+    }
+    return newName;
+  }
+
+  /**
+   * Compare existing worker configuration
+   *
+   * @param {Object} config - Deployment configuration
+   */
+  async compareExistingWorker(config) {
+    console.log('\n🔍 Comparing Worker Configurations:');
+    console.log('=====================================');
+    try {
+      // This is a simplified comparison - in a real implementation,
+      // you might fetch the existing worker's configuration
+      console.log(`   📋 Existing Worker: ${config.worker.name}`);
+      console.log(`   🌐 URL: https://${config.worker.name}.${config.credentials?.zoneName || 'tamylatrading.workers.dev'}`);
+      console.log(`   📅 Last deployed: Unknown (would need API call to check)`);
+      console.log(`   🔧 Environment: ${config.environment || 'production'}`);
+      console.log('\n   📋 New Deployment:');
+      console.log(`   📋 Worker: ${config.worker.name}`);
+      console.log(`   🌐 URL: ${config.worker.url}`);
+      console.log(`   🔧 Environment: ${config.environment || 'production'}`);
+      console.log(`   🗄️ Database: ${config.database?.name || 'None'}`);
+      console.log(`   🔐 Secrets: ${Object.keys(config.secrets || {}).length} configured`);
+      console.log('\n   ℹ️ Note: Full comparison would require additional API calls to fetch existing worker details');
+    } catch (error) {
+      console.log(`   ⚠️ Could not compare configurations: ${error.message}`);
+    }
+  }
+
+  /**
+   * Create a backup of existing worker
+   *
+   * @param {Object} config - Deployment configuration
+   */
+  async backupExistingWorker(config) {
+    console.log('\n💾 Creating Worker Backup:');
+    console.log('===========================');
+    try {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupName = `${config.worker.name}-backup-${timestamp}`;
+      console.log(`   📋 Creating backup worker: ${backupName}`);
+
+      // Note: This is a placeholder - actual backup would require
+      // downloading the existing worker code and creating a new worker
+      // This would be complex and might not be worth implementing
+      // since Cloudflare doesn't provide direct worker code access
+
+      console.log(`   ⚠️ Worker backup not fully implemented yet`);
+      console.log(`   💡 Consider manually backing up important worker code before overwriting`);
+      console.log(`   💡 You can also use version control to track changes`);
+    } catch (error) {
+      console.log(`   ⚠️ Backup failed: ${error.message}`);
+      console.log(`   🔄 Continuing with deployment anyway...`);
+    }
+  }
+
   /**
    * Execute comprehensive validation
    * 

package/dist/utils/cloudflare/api.js

@@ -242,6 +242,22 @@ export class CloudflareAPI {
     }));
   }
 
+  /**
+   * Put a secret for a worker
+   * @param {string} accountId - Account ID
+   * @param {string} scriptName - Worker script name
+   * @param {string} secretName - Secret name
+   * @param {Object} secretValue - Secret value object with 'text' property
+   * @returns {Promise<Object>} API response
+   */
+  async putWorkerSecret(accountId, scriptName, secretName, secretValue) {
+    const data = await this.request(`/accounts/${accountId}/workers/scripts/${scriptName}/secrets/${secretName}`, {
+      method: 'PUT',
+      body: JSON.stringify(secretValue)
+    });
+    return data;
+  }
+
   /**
    * List D1 databases for an account
    * @param {string} accountId - Account ID

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamyla/clodo-framework",
-  "version": "4.0.2",
+  "version": "4.0.4",
   "description": "Reusable framework for Clodo-style software architecture on Cloudflare Workers + D1",
   "type": "module",
   "sideEffects": [
@@ -100,6 +100,7 @@
     "check:bundle": "node scripts/utilities/check-bundle.js || echo 'Bundle check passed'",
     "check:imports": "node scripts/utilities/check-import-paths.js",
     "check:all": "npm run type-check && npm run test",
+    "diagnose": "node scripts/framework-diagnostic.js",
     "analyze:bundle": "echo 'Bundle analysis not implemented yet'",
     "docs": "echo 'JSDoc documentation generation not configured yet'",
     "validate": "npm run check:all",