@tamyla/clodo-framework 1.0.0

package/dist/shared/cloudflare/index.js

@@ -0,0 +1,8 @@
+/**
+ * Cloudflare Integration Module
+ * Exports all Cloudflare-related utilities and managers
+ */
+
+export { CloudflareDomainManager } from './domain-manager.js';
+export { DomainDiscovery } from './domain-discovery.js';
+export { CloudflareOps } from './ops.js';

package/dist/shared/cloudflare/ops.js

@@ -0,0 +1,387 @@
+/**
+ * Cloudflare Operations Module
+ * Standardized Cloudflare Workers and D1 operations
+ * 
+ * Consolidates cloudflare operations across 14+ scripts
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { executeWithRateLimit } from '../utils/rate-limiter.js';
+import { ErrorRecoveryManager } from '../utils/error-recovery.js';
+import { SecureTokenManager } from '../security/secure-token-manager.js';
+import { ProductionMonitor } from '../monitoring/production-monitor.js';
+import { DatabaseConnectionManager } from '../database/connection-manager.js';
+import { startMemoryMonitoring } from '../monitoring/memory-manager.js';
+import { initializeGracefulShutdown } from '../utils/graceful-shutdown-manager.js';
+const execAsync = promisify(exec);
+
+// Error recovery for critical operations
+const errorRecovery = new ErrorRecoveryManager({
+  maxRetries: 2,
+  retryDelay: 2000,
+  circuitBreakerThreshold: 3,
+  gracefulDegradation: true
+});
+
+// Secure token management
+const tokenManager = new SecureTokenManager();
+
+// Production monitoring
+const monitor = new ProductionMonitor({
+  logLevel: 'info',
+  enableMetrics: true,
+  enableAlerts: true
+});
+
+// Database connection management
+const dbManager = new DatabaseConnectionManager({
+  maxRetries: 2,
+  retryDelay: 1000,
+  connectionTimeout: 30000,
+  queryTimeout: 60000,
+  enableConnectionPooling: true,
+  maxPoolSize: 5
+});
+
+// Memory management
+const memoryManager = startMemoryMonitoring({
+  gcInterval: 300000,
+  // 5 minutes
+  memoryThreshold: 0.8,
+  cleanupInterval: 60000,
+  // 1 minute
+  leakDetection: true
+});
+
+// Graceful shutdown handling (async initialization)
+let shutdownManager = null;
+(async () => {
+  shutdownManager = await initializeGracefulShutdown({
+    dbManager,
+    monitor,
+    tokenManager,
+    memoryManager
+  }, {
+    shutdownTimeout: 30000,
+    forceShutdownTimeout: 5000
+  });
+})().catch(console.error);
+
+// Initialize monitoring
+let monitoringInitialized = false;
+async function ensureMonitoringInitialized() {
+  if (!monitoringInitialized) {
+    await monitor.startMonitoring();
+    monitoringInitialized = true;
+  }
+}
+
+// Initialize secure token manager
+let tokenManagerInitialized = false;
+async function ensureTokenManagerInitialized() {
+  if (!tokenManagerInitialized) {
+    await tokenManager.initialize();
+    tokenManagerInitialized = true;
+  }
+}
+export async function checkAuth() {
+  try {
+    await ensureTokenManagerInitialized();
+    // Try to get a valid token for Cloudflare API
+    const tokens = tokenManager.listTokens('cloudflare');
+    if (tokens.length === 0) {
+      return false;
+    }
+
+    // Check if we have a non-expired token
+    const validToken = tokens.find(token => new Date() < token.expires);
+    return !!validToken;
+  } catch (error) {
+    return false;
+  }
+}
+export async function authenticate() {
+  try {
+    // Use wrangler auth login for initial authentication
+    await execAsync('npx wrangler auth login', {
+      stdio: 'inherit'
+    });
+
+    // After successful login, we could extract and store the token securely
+    // For now, rely on wrangler's built-in token management
+    console.log('Authentication successful. Use storeCloudflareToken() to store API tokens securely.');
+  } catch (error) {
+    throw new Error(`Authentication failed: ${error.message}`);
+  }
+}
+export async function storeCloudflareToken(token, metadata = {}) {
+  await ensureTokenManagerInitialized();
+  const fingerprint = await tokenManager.storeToken('cloudflare', token, {
+    permissions: ['api_access', 'deployment'],
+    environment: metadata.environment || 'production',
+    ...metadata
+  });
+  console.log(`Cloudflare API token stored securely with fingerprint: ${fingerprint}`);
+  return fingerprint;
+}
+export async function getCloudflareToken(requiredPermissions = ['api_access']) {
+  await ensureTokenManagerInitialized();
+  const tokens = tokenManager.listTokens('cloudflare');
+
+  // Find a valid token with required permissions
+  for (const tokenInfo of tokens) {
+    if (new Date() < tokenInfo.expires && tokenManager.validatePermissions(tokenInfo.permissions, requiredPermissions)) {
+      return await tokenManager.retrieveToken('cloudflare', tokenInfo.fingerprint, requiredPermissions);
+    }
+  }
+  throw new Error('No valid Cloudflare API token found with required permissions');
+}
+export async function listWorkers() {
+  try {
+    const {
+      stdout: list
+    } = await executeWithRateLimit('npx wrangler list', 'workers');
+    return list;
+  } catch (error) {
+    throw new Error(`Failed to list workers: ${error.message}`);
+  }
+}
+export async function workerExists(workerName) {
+  try {
+    const list = await listWorkers();
+    return list.includes(workerName);
+  } catch (error) {
+    return false; // Assume doesn't exist if can't check
+  }
+}
+export async function deployWorker(env = 'production') {
+  const startTime = Date.now();
+  try {
+    await ensureMonitoringInitialized();
+    const result = await errorRecovery.executeWithRecovery(async () => {
+      await executeWithRateLimit(`npm run deploy:${env}`, 'workers');
+      return true;
+    }, {
+      operationId: `deployWorker_${env}`
+    });
+    const duration = Date.now() - startTime;
+    monitor.recordRequest(true, duration, {
+      operation: 'deployWorker',
+      env
+    });
+    await monitor.log('info', 'Worker deployment successful', {
+      env,
+      duration
+    });
+    return result;
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    monitor.recordRequest(false, duration, {
+      operation: 'deployWorker',
+      env,
+      error: error.message
+    });
+    await monitor.log('error', 'Worker deployment failed', {
+      env,
+      duration,
+      error: error.message
+    });
+    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}`;
+  try {
+    await executeWithRateLimit(command, 'workers', 3); // Lower retries for secrets
+  } catch (error) {
+    throw new Error(`Secret deployment failed: ${error.message}`);
+  }
+}
+export async function deleteSecret(key, env = 'production') {
+  try {
+    await executeWithRateLimit(`npx wrangler secret delete ${key} --env ${env}`, 'workers');
+  } catch (error) {
+    throw new Error(`Secret deletion failed: ${error.message}`);
+  }
+}
+export async function listSecrets(env = 'production') {
+  try {
+    const {
+      stdout: list
+    } = await executeWithRateLimit(`npx wrangler secret list --env ${env}`, 'workers');
+    return list;
+  } catch (error) {
+    throw new Error(`Failed to list secrets: ${error.message}`);
+  }
+}
+export async function listDatabases() {
+  try {
+    const {
+      stdout: list
+    } = await executeWithRateLimit('npx wrangler d1 list', 'd1');
+    return list;
+  } catch (error) {
+    throw new Error(`Failed to list databases: ${error.message}`);
+  }
+}
+export async function databaseExists(databaseName) {
+  try {
+    const list = await listDatabases();
+    return list.includes(databaseName);
+  } catch (error) {
+    return false; // Assume doesn't exist if can't check
+  }
+}
+export async function createDatabase(name) {
+  try {
+    const {
+      stdout: output
+    } = await executeWithRateLimit(`npx wrangler d1 create ${name}`, 'd1');
+    const idMatch = output.match(/database_id = "([^"]+)"/);
+    if (!idMatch) {
+      throw new Error('Could not extract database ID from creation output');
+    }
+    return idMatch[1];
+  } catch (error) {
+    throw new Error(`Database creation failed: ${error.message}`);
+  }
+}
+export async function deleteDatabase(name) {
+  try {
+    await executeWithRateLimit(`npx wrangler d1 delete ${name} --skip-confirmation`, 'd1');
+  } catch (error) {
+    throw new Error(`Database deletion failed: ${error.message}`);
+  }
+}
+export async function runMigrations(databaseName, env = 'production') {
+  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');
+      return true;
+    }, {
+      operationId: `runMigrations_${databaseName}_${env}`
+    });
+    const duration = Date.now() - startTime;
+    monitor.recordRequest(true, duration, {
+      operation: 'runMigrations',
+      databaseName,
+      env
+    });
+    await monitor.log('info', 'Database migrations completed', {
+      databaseName,
+      env,
+      duration
+    });
+    return result;
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    monitor.recordRequest(false, duration, {
+      operation: 'runMigrations',
+      databaseName,
+      env,
+      error: error.message
+    });
+    await monitor.log('warn', 'Database migrations had warnings', {
+      databaseName,
+      env,
+      duration,
+      error: error.message
+    });
+    return false; // Warnings are often OK
+  }
+}
+export async function executeSql(databaseName, sql, env = 'production') {
+  const startTime = Date.now();
+  try {
+    await ensureMonitoringInitialized();
+    const result = await dbManager.executeQuery(databaseName, sql, {
+      env
+    });
+    const duration = Date.now() - startTime;
+    monitor.recordRequest(true, duration, {
+      operation: 'executeSql',
+      databaseName,
+      env
+    });
+    await monitor.log('info', 'Database query executed successfully', {
+      databaseName,
+      env,
+      duration,
+      resultLength: result.result ? result.result.length : 0
+    });
+    return result.result;
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    monitor.recordRequest(false, duration, {
+      operation: 'executeSql',
+      databaseName,
+      env,
+      error: error.message
+    });
+    await monitor.log('error', 'Database query failed', {
+      databaseName,
+      env,
+      duration,
+      error: error.message
+    });
+    throw new Error(`SQL execution failed after retries: ${error.message}`);
+  }
+}
+
+// Get database ID from list output
+export async function getDatabaseId(databaseName) {
+  try {
+    const list = await listDatabases();
+    const lines = list.split('\n');
+    for (const line of lines) {
+      if (line.includes(databaseName)) {
+        const match = line.match(/([a-f0-9-]{36})/);
+        if (match) {
+          return match[1];
+        }
+      }
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+
+// Validate prerequisites
+export async function validatePrerequisites() {
+  const checks = [{
+    name: 'Node.js',
+    command: 'node --version'
+  }, {
+    name: 'NPM',
+    command: 'npm --version'
+  }, {
+    name: 'Wrangler',
+    command: 'npx wrangler --version'
+  }];
+  const results = [];
+  for (const check of checks) {
+    try {
+      const {
+        stdout: version
+      } = await execAsync(check.command, {
+        encoding: 'utf8'
+      });
+      results.push({
+        name: check.name,
+        status: 'ok',
+        version: version.trim()
+      });
+    } catch (error) {
+      results.push({
+        name: check.name,
+        status: 'failed',
+        error: error.message
+      });
+    }
+  }
+  return results;
+}