@tamyla/clodo-framework 4.0.13 → 4.0.14

package/scripts/README-test-clodo-deployment.md

@@ -0,0 +1,157 @@
+# Clodo Service Deployment Testing Script
+
+A comprehensive local testing script for the clodo-service deployment process that safely simulates the information collection, consolidation, and deployment execution phases without making actual Cloudflare API calls.
+
+## Overview
+
+This script tests the complete deployment workflow by:
+1. **Information Collection**: Service detection and manifest parsing
+2. **Consolidation**: Credential gathering and configuration validation
+3. **Execution**: Simulated deployment with detailed phase-by-phase logging
+
+## Usage
+
+```bash
+# Basic test (recommended for development)
+node scripts/test-clodo-deployment.js
+
+# Test specific phase only
+node scripts/test-clodo-deployment.js --test-phase collection
+node scripts/test-clodo-deployment.js --test-phase consolidation
+node scripts/test-clodo-deployment.js --test-phase execution
+
+# Advanced options
+node scripts/test-clodo-deployment.js --verbose --service-path ./my-service
+node scripts/test-clodo-deployment.js --no-mock-credentials  # Requires real credentials
+node scripts/test-clodo-deployment.js --no-dry-run          # Actually deploy (dangerous!)
+```
+
+## Command Line Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--service-path <path>` | Path to service directory | Current directory |
+| `--dry-run` | Simulate deployment without changes | `true` (safe) |
+| `--no-dry-run` | Actually perform deployment | `false` |
+| `--verbose` | Detailed logging output | `false` |
+| `--mock-credentials` | Use mock credentials for testing | `true` (safe) |
+| `--no-mock-credentials` | Require real Cloudflare credentials | `false` |
+| `--test-phase <phase>` | Test specific phase: `all`, `collection`, `consolidation`, `execution` | `all` |
+| `--help` | Show help message | - |
+
+## Testing Phases
+
+### Phase 1: Information Collection
+- Detects if current directory is a Clodo service project
+- Parses `clodo-service-manifest.json` for service configuration
+- Validates project structure and required files
+- Extracts service name, type, domain, and environment
+
+### Phase 2: Consolidation
+- Analyzes credential gathering strategy (flags → env vars → prompt)
+- Consolidates deployment configuration from multiple sources
+- Validates all required information is present
+- Creates comprehensive deployment plan
+
+### Phase 3: Execution
+- Simulates complete deployment workflow
+- Tests each deployment phase with realistic timing
+- Validates post-deployment checks
+- Generates mock deployment results
+
+## Safety Features
+
+- **Dry Run by Default**: No actual deployments or API calls by default
+- **Mock Credentials**: Uses safe test credentials unless explicitly disabled
+- **Comprehensive Validation**: Tests all validation logic without side effects
+- **Detailed Logging**: Shows exactly what would happen in real deployment
+
+## Example Output
+
+```
+[14:23:15] 🚀 Starting Clodo Service Deployment Testing
+[14:23:15] 📋 Test Phase: all
+[14:23:15] 📋 Service Path: C:\path\to\service
+[14:23:15] 📋 Dry Run: true
+
+[14:23:15] 🚀 Phase 1: Information Collection
+[14:23:15] 📋 Step 1: Detecting service project...
+[14:23:15] ✅ Found existing service manifest
+[14:23:15] 📋 Step 2: Parsing service information...
+[14:23:15] 📋 Service Name: my-test-service
+[14:23:15] 📋 Service Type: data-service
+[14:23:15] 📋 Domain: test-service.example.com
+[14:23:15] ✅ Information collection completed in 45ms
+
+[14:23:15] 🚀 Phase 2: Information Consolidation
+[14:23:15] 📋 Step 1: Analyzing credential gathering strategy...
+[14:23:15] 📋 Using mock credentials for testing
+[14:23:15] 📋 Credential Sources:
+[14:23:15] 📋   Environment Variables: ❌
+[14:23:15] 📋   Mock Credentials: ✅
+[14:23:15] ✅ Information consolidation completed in 23ms
+
+[14:23:15] 🚀 Phase 3: Deployment Execution Simulation
+[14:23:15] 📋 Step 2: Simulating deployment phases...
+[14:23:15] 📋   Executing: Initialization...
+[14:23:15] ✅ Initialization completed
+[14:23:15] 📋   Executing: Configuration Validation...
+[14:23:15] ✅ Configuration Validation completed
+... (additional phases)
+[14:23:16] ✅ Deployment execution simulation completed in 5423ms
+
+[14:23:16] 🎉 Clodo Service Deployment Testing Complete
+```
+
+## Use Cases
+
+### Development Testing
+```bash
+# Test deployment logic during development
+node scripts/test-clodo-deployment.js --verbose
+```
+
+### CI/CD Integration
+```bash
+# Validate deployment configuration in CI
+node scripts/test-clodo-deployment.js --test-phase collection --test-phase consolidation
+```
+
+### Debugging
+```bash
+# Isolate specific deployment issues
+node scripts/test-clodo-deployment.js --test-phase execution --verbose
+```
+
+### Service Validation
+```bash
+# Validate service configuration before deployment
+node scripts/test-clodo-deployment.js --service-path ./my-service --test-phase collection
+```
+
+## Integration with Real Deployment
+
+The testing script validates the same logic as the actual deployment:
+
+1. **Manifest Parsing**: Same JSON parsing and validation as `deploy.js`
+2. **Credential Logic**: Same priority order (flags → env → prompt) as real deployment
+3. **Configuration Consolidation**: Same validation and consolidation logic
+4. **Deployment Phases**: Simulates the same phases as `ModularEnterpriseDeployer`
+
+## Troubleshooting
+
+### "No manifest found" Error
+The script will create a mock manifest for testing. For real services, ensure `clodo-service-manifest.json` exists.
+
+### Credential Issues
+Use `--mock-credentials` for testing, or provide real Cloudflare credentials via environment variables.
+
+### Permission Errors
+Ensure the script has read/write access to the service directory.
+
+## Related Files
+
+- `bin/commands/deploy.js` - Actual deployment command
+- `bin/deployment/modular-enterprise-deploy.js` - Deployment orchestrator
+- `clodo-service-manifest.json` - Service configuration file
+- `README.md` - General framework documentation

package/scripts/README.md

@@ -0,0 +1,50 @@
+# Clodo Framework Scripts
+
+This directory contains organized scripts for the Clodo Framework, categorized by functionality.
+
+## Categories
+
+### service-management/
+Scripts for creating and setting up new services.
+
+- `setup-interactive.ps1` - Interactive service setup wizard
+
+### deployment/
+Scripts for deploying services to various environments.
+
+- `deploy-domain.ps1` - Deploy services to specific domains
+
+### testing/
+Scripts for testing services and functionality.
+
+- `test.ps1` - Basic test runner
+- `test-first.ps1` - Test first service/item
+- `test-first50.ps1` - Test first 50 services/items
+
+### utilities/
+General utility scripts for maintenance and operations.
+
+- `check-bundle.js` - Bundle validation script
+- `cleanup-cli.js` - CLI cleanup utilities
+- `generate-secrets.js` - Secret generation utilities
+- `validate-schema.js` - Schema validation tools
+
+### database/
+Database-related scripts and utilities.
+
+*(Currently empty - database scripts are in bin/database/)*
+
+## Usage
+
+Run scripts from the project root using relative paths:
+
+```powershell
+# Service management
+.\scripts\service-management\setup-interactive.ps1
+
+# Deployment
+.\scripts\deployment\deploy-domain.ps1 -DomainName example.com
+
+# Testing
+.\scripts\testing\test.ps1
+```

package/scripts/analyze-imports.ps1

@@ -0,0 +1,104 @@
+
+# Script to extract all imports from documentation and templates
+$results = @()
+$symbolSet = @{}
+
+function Extract-Imports {
+    param (
+        [string]$FilePath,
+        [string]$RelativePath
+    )
+    
+    $content = Get-Content $FilePath -Raw
+    $pattern = "import\s+\{([^}]+)\}\s+from\s+['\`"](@tamyla/clodo-framework[^'\`"]*)['\`"]"
+    
+    $matches = [regex]::Matches($content, $pattern)
+    
+    foreach ($match in $matches) {
+        $symbolsString = $match.Groups[1].Value
+        $package = $match.Groups[2].Value
+        
+        # Split symbols by comma and clean them
+        $symbols = $symbolsString -split ',' | ForEach-Object { 
+            $_.Trim() -replace '\s+', ' '
+        } | Where-Object { $_ -ne '' }
+        
+        foreach ($symbol in $symbols) {
+            $key = "$symbol|$package"
+            if (-not $symbolSet.ContainsKey($key)) {
+                $symbolSet[$key] = @()
+            }
+            $symbolSet[$key] += $RelativePath
+            
+            $script:results += [PSCustomObject]@{
+                Symbol = $symbol
+                Package = $package
+                File = $RelativePath
+            }
+        }
+    }
+}
+
+# Process README.md
+Write-Host "Processing README.md..."
+Extract-Imports -FilePath "README.md" -RelativePath "README.md"
+
+# Process docs/
+Write-Host "Processing docs/..."
+Get-ChildItem -Path "docs" -Filter "*.md" -Recurse | ForEach-Object {
+    $relativePath = $_.FullName -replace [regex]::Escape($PWD.Path + "\"), ""
+    Extract-Imports -FilePath $_.FullName -RelativePath $relativePath
+}
+
+# Process i-docs/
+Write-Host "Processing i-docs/..."
+Get-ChildItem -Path "i-docs" -Filter "*.md" -Recurse | ForEach-Object {
+    $relativePath = $_.FullName -replace [regex]::Escape($PWD.Path + "\"), ""
+    Extract-Imports -FilePath $_.FullName -RelativePath $relativePath
+}
+
+# Process templates/
+Write-Host "Processing templates/..."
+Get-ChildItem -Path "templates" -Recurse -Include "*.js","*.md" | ForEach-Object {
+    $relativePath = $_.FullName -replace [regex]::Escape($PWD.Path + "\"), ""
+    Extract-Imports -FilePath $_.FullName -RelativePath $relativePath
+}
+
+# Create unique list with file references
+$uniqueImports = @()
+foreach ($key in $symbolSet.Keys) {
+    $parts = $key -split '\|'
+    $symbol = $parts[0]
+    $package = $parts[1]
+    $files = $symbolSet[$key] | Select-Object -Unique
+    
+    $uniqueImports += [PSCustomObject]@{
+        symbol = $symbol
+        package = $package
+        foundIn = @($files)
+    }
+}
+
+# Sort by symbol name
+$uniqueImports = $uniqueImports | Sort-Object -Property symbol
+
+# Convert to JSON
+$json = $uniqueImports | ConvertTo-Json -Depth 10
+
+# Save to file
+$outputFile = "documented-imports.json"
+$json | Out-File -FilePath $outputFile -Encoding UTF8
+
+Write-Host "`nAnalysis complete!"
+Write-Host "Total import statements found: $($results.Count)"
+Write-Host "Unique symbols found: $($uniqueImports.Count)"
+Write-Host "Output saved to: $outputFile"
+
+# Display summary
+Write-Host "`nUnique symbols by package:"
+$uniqueImports | Group-Object -Property package | Sort-Object Count -Descending | ForEach-Object {
+    Write-Host "  $($_.Name): $($_.Count) symbols"
+}
+
+# Return the JSON
+Write-Output $json

package/scripts/analyze-mixed-code.js

@@ -0,0 +1,163 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const workerCompatiblePatterns = [
+  /fetch\(/,
+  /Response\(/,
+  /Request/,
+  /env\./,
+  /ctx\./,
+  /export.*default.*{.*fetch/,
+  /initializeService/,
+  /createFeatureGuard/,
+  /COMMON_FEATURES/,
+  /createDomainConfigSchema/,
+  /validateDomainConfig/,
+  /getDomainFromEnv/,
+  /createEnvironmentConfig/
+];
+
+const nodeOnlyPatterns = [
+  /import.*from.*['"]fs['"]/,
+  /import.*from.*['"]path['"]/,
+  /import.*from.*['"]child_process['"]/,
+  /import.*from.*['"]os['"]/,
+  /import.*from.*['"]https['"]/,
+  /import.*from.*['"]http['"]/,
+  /readFileSync|writeFileSync|existsSync|mkdirSync|readdirSync|statSync/,
+  /spawn|execSync|exec\(/,
+  /process\.cwd\(\)/,
+  /__dirname(?!\s*=)/,
+  /__filename(?!\s*=)/
+];
+
+function scanFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split('\n');
+
+  const workerCode = [];
+  const nodeCode = [];
+  const potentialMixedLines = [];
+
+  lines.forEach((line, index) => {
+    const lineNum = index + 1;
+    const trimmedLine = line.trim();
+    
+    if (trimmedLine.startsWith('//') || trimmedLine.startsWith('*')) return;
+
+    let hasWorker = false;
+    let hasNode = false;
+
+    for (const pattern of workerCompatiblePatterns) {
+      if (pattern.test(trimmedLine)) {
+        hasWorker = true;
+        workerCode.push({ line: lineNum, content: trimmedLine });
+        break;
+      }
+    }
+
+    for (const pattern of nodeOnlyPatterns) {
+      if (pattern.test(trimmedLine)) {
+        hasNode = true;
+        nodeCode.push({ line: lineNum, content: trimmedLine, pattern: pattern.toString() });
+        break;
+      }
+    }
+
+    if (hasWorker && hasNode) {
+      potentialMixedLines.push({ line: lineNum, content: trimmedLine });
+    }
+  });
+
+  return {
+    hasWorkerCode: workerCode.length > 0,
+    hasNodeCode: nodeCode.length > 0,
+    isMixed: workerCode.length > 0 && nodeCode.length > 0,
+    workerCodeCount: workerCode.length,
+    nodeCodeCount: nodeCode.length,
+    workerCode,
+    nodeCode,
+    potentialMixedLines
+  };
+}
+
+function scanDirectory(dir, results = []) {
+  try {
+    const items = fs.readdirSync(dir);
+    for (const item of items) {
+      const fullPath = path.join(dir, item);
+      const stat = fs.statSync(fullPath);
+      if (stat.isDirectory() && !item.startsWith('.') && item !== 'node_modules') {
+        scanDirectory(fullPath, results);
+      } else if (item.endsWith('.js')) {
+        const analysis = scanFile(fullPath);
+        if (analysis.hasWorkerCode || analysis.hasNodeCode) {
+          results.push({
+            file: fullPath.replace(process.cwd(), ''),
+            ...analysis
+          });
+        }
+      }
+    }
+  } catch (e) {}
+  return results;
+}
+
+console.log('╔════════════════════════════════════════════════════════════╗');
+console.log('║  DEEP ANALYSIS: Worker vs Node.js Code in Framework       ║');
+console.log('╚════════════════════════════════════════════════════════════╝\n');
+
+const results = scanDirectory('src');
+
+// Categorize results
+const pureNodeOnly = results.filter(r => !r.hasWorkerCode && r.hasNodeCode);
+const pureWorkerCode = results.filter(r => r.hasWorkerCode && !r.hasNodeCode);
+const mixedCode = results.filter(r => r.isMixed);
+
+console.log(`📊 OVERALL SUMMARY:`);
+console.log(`   Total files analyzed: ${results.length}`);
+console.log(`   Pure Node.js only: ${pureNodeOnly.length}`);
+console.log(`   Pure Worker code: ${pureWorkerCode.length}`);
+console.log(`   MIXED code (both): ${mixedCode.length}\n`);
+
+if (mixedCode.length > 0) {
+  console.log(`╔════════════════════════════════════════════════════════════╗`);
+  console.log(`║  ⚠️  FILES WITH MIXED CODE (Worker + Node.js)             ║`);
+  console.log(`╚════════════════════════════════════════════════════════════╝\n`);
+  
+  mixedCode.forEach(file => {
+    console.log(`\n📄 ${file.file}`);
+    console.log(`   Worker code lines: ${file.workerCodeCount}`);
+    console.log(`   Node.js code lines: ${file.nodeCodeCount}`);
+    console.log(`   Worker patterns found:`);
+    file.workerCode.slice(0, 3).forEach(w => {
+      console.log(`     • Line ${w.line}: ${w.content.substring(0, 60)}`);
+    });
+    console.log(`   Node.js patterns found:`);
+    file.nodeCode.slice(0, 3).forEach(n => {
+      console.log(`     • Line ${n.line}: ${n.content.substring(0, 60)}`);
+    });
+  });
+}
+
+console.log(`\n╔════════════════════════════════════════════════════════════╗`);
+console.log(`║  PURE NODE.JS FILES (No Worker Code)                     ║`);
+console.log(`╚════════════════════════════════════════════════════════════╝\n`);
+
+pureNodeOnly.forEach(file => {
+  console.log(`${file.file.substring(0, 80)}`);
+});
+
+console.log(`\n╔════════════════════════════════════════════════════════════╗`);
+console.log(`║  PURE WORKER CODE (No Node.js Dependencies)              ║`);
+console.log(`╚════════════════════════════════════════════════════════════╝\n`);
+
+pureWorkerCode.forEach(file => {
+  console.log(`${file.file.substring(0, 80)}`);
+});
+
+console.log(`\n\n═══════════════════════════════════════════════════════════\n`);

package/scripts/analyze-mixed-rationale.js

@@ -0,0 +1,149 @@
+import fs from 'fs';
+import path from 'path';
+
+const mixedFiles = [
+  'src/config/customers.js',
+  'src/database/database-orchestrator.js',
+  'src/deployment/wrangler-deployer.js',
+  'src/orchestration/multi-domain-orchestrator.js',
+  'src/service-management/GenerationEngine.js',
+  'src/service-management/generators/code/ServiceHandlersGenerator.js',
+  'src/service-management/generators/code/ServiceMiddlewareGenerator.js',
+  'src/service-management/generators/code/ServiceUtilsGenerator.js',
+  'src/service-management/generators/code/WorkerIndexGenerator.js',
+  'src/service-management/generators/config/DomainsConfigGenerator.js',
+  'src/service-management/generators/config/EnvExampleGenerator.js',
+  'src/service-management/generators/config/WranglerTomlGenerator.js',
+  'src/service-management/generators/documentation/ApiDocsGenerator.js',
+  'src/service-management/generators/documentation/ConfigurationDocsGenerator.js',
+  'src/service-management/generators/documentation/ReadmeGenerator.js',
+  'src/service-management/generators/schemas/ServiceSchemaGenerator.js',
+  'src/service-management/generators/scripts/HealthCheckScriptGenerator.js',
+  'src/service-management/generators/scripts/SetupScriptGenerator.js',
+  'src/service-management/generators/testing/EslintConfigGenerator.js',
+  'src/service-management/generators/testing/IntegrationTestsGenerator.js',
+  'src/service-management/generators/testing/UnitTestsGenerator.js',
+  'src/service-management/generators/tooling/GitignoreGenerator.js',
+  'src/service-management/handlers/ValidationHandler.js',
+  'src/service-management/ServiceOrchestrator.js',
+  'src/utils/config/unified-config-manager.js',
+  'src/utils/deployment/config-cache.js',
+  'src/utils/deployment/secret-generator.js',
+  'src/utils/deployment/wrangler-config-manager.js',
+  'src/utils/framework-config.js'
+];
+
+console.log('╔════════════════════════════════════════════════════════════╗');
+console.log('║  ANALYSIS: Why These 29 Files Have Mixed Code             ║');
+console.log('╚════════════════════════════════════════════════════════════╝\n');
+
+const categories = {
+  'GENERATORS THAT SCAFFOLD WORKER CODE': [
+    {
+      file: 'src/service-management/generators/code/ServiceHandlersGenerator.js',
+      reason: 'Writes template files (.js) to disk that contain Worker code (async fetch, Response, etc.). Node.js: fs, path for file writing. Worker: Content it generates has Request/Response.',
+      usesNodeFor: 'File generation',
+      workerConnection: 'Generates Worker handler files'
+    },
+    {
+      file: 'src/service-management/generators/code/ServiceUtilsGenerator.js',
+      reason: 'Generates utility functions for Workers that use env.DB and Response objects. Node.js needed for file operations.',
+      usesNodeFor: 'File generation',
+      workerConnection: 'Generates utility library for Workers'
+    },
+    {
+      file: 'src/service-management/generators/code/WorkerIndexGenerator.js',
+      reason: 'Generates the main Worker entry point file with async fetch() handler. Node.js for file I/O.',
+      usesNodeFor: 'File generation',
+      workerConnection: 'Generates actual Worker code'
+    },
+    {
+      file: 'src/service-management/generators/testing/IntegrationTestsGenerator.js',
+      reason: 'Generates test files that use fetch() and Worker URLs. Node.js for file generation and test setup.',
+      usesNodeFor: 'File generation',
+      workerConnection: 'Generates tests that target Worker endpoints'
+    }
+  ],
+  'CONFIG GENERATORS FOR WORKER ENVIRONMENTS': [
+    {
+      file: 'src/service-management/generators/config/WranglerTomlGenerator.js',
+      reason: 'Generates wrangler.toml with Worker configuration. References [env] sections for different Worker environments.',
+      usesNodeFor: 'File generation',
+      workerConnection: 'Generates Worker deployment config'
+    },
+    {
+      file: 'src/service-management/generators/config/DomainsConfigGenerator.js',
+      reason: 'Generates domain config files that are used by Workers at runtime.',
+      usesNodeFor: 'File generation',
+      workerConnection: 'Generates config consumed by Workers'
+    }
+  ],
+  'ORCHESTRATION THAT DEPLOYS TO WORKERS': [
+    {
+      file: 'src/deployment/wrangler-deployer.js',
+      reason: 'Orchestrates wrangler CLI to deploy Workers. Node.js: spawn/execSync for CLI. Worker references: environment detection, URL extraction.',
+      usesNodeFor: 'CLI execution for deployment',
+      workerConnection: 'Deploys code to Workers'
+    },
+    {
+      file: 'src/orchestration/multi-domain-orchestrator.js',
+      reason: 'Coordinates deployments across multiple domains/Workers. Node.js: exec for CLI. Uses process.env to configure deployments.',
+      usesNodeFor: 'CLI execution, process.env setup',
+      workerConnection: 'Deploys multiple Workers'
+    }
+  ],
+  'CONFIGURATION MANAGERS': [
+    {
+      file: 'src/config/customers.js',
+      reason: 'Loads customer domain configs used by Workers at runtime. Node.js: fs for file loading. Uses createDomainConfigSchema (Worker utility).',
+      usesNodeFor: 'File I/O',
+      workerConnection: 'Manages config for Worker environments'
+    },
+    {
+      file: 'src/utils/framework-config.js',
+      reason: 'Central framework config with extensive environment variable setup for both CLI and Workers.',
+      usesNodeFor: 'Path resolution, __dirname setup',
+      workerConnection: 'Provides config used by Workers'
+    }
+  ],
+  'PURE GENERATORS (No Worker Connection)': [
+    {
+      file: 'src/service-management/generators/cicd/DeployWorkflowGenerator.js',
+      reason: 'Generates CI/CD workflow files. Node.js for file I/O. No Worker code generated.',
+      usesNodeFor: 'File generation',
+      workerConnection: 'None - CI/CD automation only'
+    }
+  ]
+};
+
+let totalAnalyzed = 0;
+
+for (const [category, items] of Object.entries(categories)) {
+  console.log(`\n╔════════════════════════════════════════════════════════════╗`);
+  console.log(`║  ${category.padEnd(56)}║`);
+  console.log(`╚════════════════════════════════════════════════════════════╝\n`);
+  
+  items.forEach(item => {
+    totalAnalyzed++;
+    console.log(`📄 ${item.file}`);
+    console.log(`   Why mixed: ${item.reason}`);
+    console.log(`   Node.js used for: ${item.usesNodeFor}`);
+    console.log(`   Worker connection: ${item.workerConnection}`);
+    console.log();
+  });
+}
+
+console.log(`\n╔════════════════════════════════════════════════════════════╗`);
+console.log(`║  CRITICAL INSIGHT                                         ║`);
+console.log(`╚════════════════════════════════════════════════════════════╝\n`);
+
+console.log(`These 29 files have mixed code for a GOOD REASON:\n`);
+console.log(`✅ They generate, configure, or orchestrate Worker deployments`);
+console.log(`✅ They use Node.js APIs for file I/O and CLI execution`);
+console.log(`✅ They reference Worker code patterns as TEMPLATES or CONFIG`);
+console.log(`✅ They never execute IN Workers - only generate for Workers\n`);
+
+console.log(`CRITICAL: None of these 29 files should be imported by generated Workers`);
+console.log(`Generated Workers only import from '@tamyla/clodo-framework/worker' path\n`);
+
+console.log(`═══════════════════════════════════════════════════════════\n`);