claude-code-templates 1.24.0 → 1.24.2

package/components/sandbox/cloudflare/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "lib": ["ES2022"],
+    "types": ["@cloudflare/workers-types", "node"],
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": [
+    "src/**/*.ts",
+    "launcher.ts",
+    "monitor.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    ".wrangler"
+  ]
+}

package/components/sandbox/cloudflare/wrangler.toml

@@ -0,0 +1,50 @@
+#:schema node_modules/wrangler/config-schema.json
+name = "cloudflare-claude-sandbox"
+main = "src/index.ts"
+compatibility_date = "2024-01-01"
+compatibility_flags = ["nodejs_compat"]
+
+# Durable Objects configuration for sandbox persistence
+[[durable_objects.bindings]]
+name = "Sandbox"
+class_name = "Sandbox"
+
+# Durable Object migration (required for first deployment)
+[[migrations]]
+tag = "v1"
+new_classes = ["Sandbox"]
+
+# Environment variables (non-secret)
+[vars]
+ENVIRONMENT = "production"
+
+# Development environment configuration
+[env.development]
+vars = { ENVIRONMENT = "development" }
+
+# Staging environment configuration
+[env.staging]
+vars = { ENVIRONMENT = "staging" }
+
+# Resource limits
+[limits]
+# CPU time limit per request (milliseconds)
+cpu_ms = 50
+
+# Build configuration
+[build]
+command = ""
+
+# Observability
+[observability]
+enabled = true
+
+# Usage model - required for Durable Objects
+[usage_model]
+# Use 'bundled' for Workers Paid plan ($5/month)
+# Includes 10M requests/month and unlimited Durable Objects
+# For free tier, comment this out (limited functionality)
+# usage_model = "bundled"
+
+# Note: Uncomment the line above after setting up Workers Paid plan
+# Or remove this section entirely for the free tier (sandbox will be limited)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-templates",
-  "version": "1.24.0",
+  "version": "1.24.2",
   "description": "CLI tool to setup Claude Code configurations with framework-specific commands, automation hooks and MCP Servers for your projects",
   "main": "src/index.js",
   "bin": {
@@ -92,6 +92,7 @@
     "bin/",
     "src/",
     "components/sandbox/e2b/",
+    "components/sandbox/cloudflare/",
     "README.md"
   ],
   "devDependencies": {

package/src/index.js

@@ -1399,124 +1399,89 @@ async function installIndividualSkill(skillName, targetDir, options) {
     // Extract the actual skill name (last part of the path)
     const skillBaseName = skillName.includes('/') ? skillName.split('/').pop() : skillName;
 
-    // Skills always use SKILL.md as the main file (Anthropic standard)
-    // Format: skills/category/skill-name/SKILL.md
-    const githubUrl = `https://raw.githubusercontent.com/davila7/claude-code-templates/main/cli-tool/components/skills/${skillName}/SKILL.md`;
-
-    console.log(chalk.gray(`📥 Downloading from GitHub (main branch)...`));
-
-    const response = await fetch(githubUrl);
-    if (!response.ok) {
-      if (response.status === 404) {
-        console.log(chalk.red(`❌ Skill "${skillName}" not found`));
-        console.log(chalk.yellow('💡 Tip: Use format "category/skill-name" (e.g., creative-design/algorithmic-art)'));
-        console.log(chalk.yellow('Available categories: creative-design, development, document-processing, enterprise-communication'));
-        return false;
-      }
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-
-    const skillContent = await response.text();
-
-    // Check if there are additional files to download (e.g., referenced .md files, scripts, reference)
-    const additionalFiles = {};
+    // Use GitHub API to download ALL files and directories for the skill
+    const githubApiUrl = `https://api.github.com/repos/davila7/claude-code-templates/contents/cli-tool/components/skills/${skillName}`;
 
-    // 1. Look for references to additional files like [FORMS.md](FORMS.md) or [reference](./reference/)
-    const referencePattern = /\[([A-Z_]+\.md)\]\(\1\)|\[.*?\]\(\.\/([a-z_]+)\/\)/g;
-    let match;
+    console.log(chalk.gray(`📥 Downloading skill from GitHub (main branch)...`));
 
-    while ((match = referencePattern.exec(skillContent)) !== null) {
-      const referencedFile = match[1] || match[2];
-      const referencedUrl = githubUrl.replace('SKILL.md', referencedFile);
+    const downloadedFiles = {};
 
+    // Recursive function to download all files and directories
+    async function downloadDirectory(apiUrl, relativePath = '') {
       try {
-        console.log(chalk.gray(`📥 Downloading referenced file: ${referencedFile}...`));
-        const refResponse = await fetch(referencedUrl);
-        if (refResponse.ok) {
-          const refContent = await refResponse.text();
-          additionalFiles[`.claude/skills/${skillBaseName}/${referencedFile}`] = {
-            content: refContent,
-            executable: false
-          };
-          console.log(chalk.green(`✓ Found referenced file: ${referencedFile}`));
-        }
-      } catch (error) {
-        // Referenced file is optional, continue if not found
-        console.log(chalk.gray(`  (Referenced file ${referencedFile} not found, continuing...)`));
-      }
-    }
-
-    // 2. Try to download common directories (scripts/, reference/) from GitHub API
-    const githubApiUrl = `https://api.github.com/repos/davila7/claude-code-templates/contents/cli-tool/components/skills/${skillName}`;
+        const response = await fetch(apiUrl, {
+          headers: {
+            'Accept': 'application/vnd.github.v3+json',
+            'User-Agent': 'claude-code-templates'
+          }
+        });
 
-    try {
-      const dirResponse = await fetch(githubApiUrl, {
-        headers: {
-          'Accept': 'application/vnd.github.v3+json',
-          'User-Agent': 'claude-code-templates'
+        if (!response.ok) {
+          if (response.status === 404) {
+            console.log(chalk.red(`❌ Skill "${skillName}" not found`));
+            console.log(chalk.yellow('💡 Tip: Use format "category/skill-name" (e.g., creative-design/algorithmic-art)'));
+            console.log(chalk.yellow('Available categories: creative-design, development, document-processing, enterprise-communication'));
+            return false;
+          }
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
         }
-      });
-
-      if (dirResponse.ok) {
-        const dirContents = await dirResponse.json();
-
-        // Find directories (scripts, reference, templates)
-        for (const item of dirContents) {
-          if (item.type === 'dir' && ['scripts', 'reference', 'templates'].includes(item.name)) {
-            console.log(chalk.gray(`📂 Found directory: ${item.name}/`));
 
-            // Fetch directory contents recursively
-            const subdirResponse = await fetch(item.url, {
-              headers: {
-                'Accept': 'application/vnd.github.v3+json',
-                'User-Agent': 'claude-code-templates'
-              }
-            });
-
-            if (subdirResponse.ok) {
-              const subdirContents = await subdirResponse.json();
-
-              for (const file of subdirContents) {
-                if (file.type === 'file') {
-                  try {
-                    const fileResponse = await fetch(file.download_url);
-                    if (fileResponse.ok) {
-                      const fileContent = await fileResponse.text();
-                      const isExecutable = file.name.endsWith('.py') || file.name.endsWith('.sh');
-
-                      additionalFiles[`.claude/skills/${skillBaseName}/${item.name}/${file.name}`] = {
-                        content: fileContent,
-                        executable: isExecutable
-                      };
-                      console.log(chalk.green(`✓ Downloaded: ${item.name}/${file.name}`));
-                    }
-                  } catch (err) {
-                    console.log(chalk.gray(`  (Could not download ${item.name}/${file.name})`));
-                  }
-                }
+        const contents = await response.json();
+
+        for (const item of contents) {
+          const itemPath = relativePath ? `${relativePath}/${item.name}` : item.name;
+
+          if (item.type === 'file') {
+            // Download file
+            try {
+              const fileResponse = await fetch(item.download_url);
+              if (fileResponse.ok) {
+                const fileContent = await fileResponse.text();
+                const isExecutable = item.name.endsWith('.py') || item.name.endsWith('.sh');
+
+                const targetPath = `.claude/skills/${skillBaseName}/${itemPath}`;
+                downloadedFiles[targetPath] = {
+                  content: fileContent,
+                  executable: isExecutable
+                };
+                console.log(chalk.green(`✓ Downloaded: ${itemPath}`));
               }
+            } catch (err) {
+              console.log(chalk.gray(`  (Could not download ${itemPath})`));
             }
+          } else if (item.type === 'dir') {
+            // Recursively download directory contents
+            console.log(chalk.gray(`📂 Downloading directory: ${itemPath}/`));
+            await downloadDirectory(item.url, itemPath);
           }
         }
+
+        return true;
+      } catch (error) {
+        console.log(chalk.gray(`  (Could not access GitHub API: ${error.message})`));
+        return false;
       }
-    } catch (error) {
-      // GitHub API access optional, continue if not available
-      console.log(chalk.gray(`  (Could not access GitHub API for directory listing)`));
     }
 
-    // Create .claude/skills/skill-name directory (Anthropic standard structure)
-    const skillsDir = path.join(targetDir, '.claude', 'skills');
-    const skillSubDir = path.join(skillsDir, skillBaseName);
-    await fs.ensureDir(skillSubDir);
+    // Download all files from the skill directory
+    const success = await downloadDirectory(githubApiUrl);
+    if (!success) {
+      return false;
+    }
 
-    // Always use SKILL.md as filename (Anthropic standard)
-    const targetFile = path.join(skillSubDir, 'SKILL.md');
+    // Check if SKILL.md was downloaded (required)
+    const skillMdPath = `.claude/skills/${skillBaseName}/SKILL.md`;
+    if (!downloadedFiles[skillMdPath]) {
+      console.log(chalk.red(`❌ SKILL.md not found in skill directory`));
+      return false;
+    }
 
-    // Write the main skill file
-    await fs.writeFile(targetFile, skillContent, 'utf8');
+    // Create .claude/skills/skill-name directory (Anthropic standard structure)
+    const skillsDir = path.join(targetDir, '.claude', 'skills');
+    await fs.ensureDir(skillsDir);
 
-    // Write any additional files
-    for (const [filePath, fileData] of Object.entries(additionalFiles)) {
+    // Write all downloaded files
+    for (const [filePath, fileData] of Object.entries(downloadedFiles)) {
       const fullPath = path.join(targetDir, filePath);
       await fs.ensureDir(path.dirname(fullPath));
       await fs.writeFile(fullPath, fileData.content, 'utf8');
@@ -1526,13 +1491,13 @@ async function installIndividualSkill(skillName, targetDir, options) {
       }
     }
 
+    const targetFile = path.join(skillsDir, skillBaseName, 'SKILL.md');
+
     if (!options.silent) {
       console.log(chalk.green(`✅ Skill "${skillName}" installed successfully!`));
       console.log(chalk.cyan(`📁 Installed to: ${path.relative(targetDir, targetFile)}`));
-      if (Object.keys(additionalFiles).length > 0) {
-        console.log(chalk.cyan(`📄 Additional files: ${Object.keys(additionalFiles).length}`));
-      }
-      console.log(chalk.cyan(`📦 Downloaded from: ${githubUrl}`));
+      console.log(chalk.cyan(`📄 Total files downloaded: ${Object.keys(downloadedFiles).length}`));
+      console.log(chalk.cyan(`📦 Downloaded from: ${githubApiUrl}`));
     }
 
     // Track successful skill installation
@@ -1540,7 +1505,7 @@ async function installIndividualSkill(skillName, targetDir, options) {
       installation_type: 'individual_skill',
       target_directory: path.relative(process.cwd(), targetDir),
       source: 'github_main',
-      has_additional_files: Object.keys(additionalFiles).length > 0
+      total_files: Object.keys(downloadedFiles).length
     });
 
     return true;
@@ -2430,10 +2395,11 @@ async function executeSandbox(options, targetDir) {
   let { agent, prompt } = options;
   
   // Validate sandbox provider
-  if (sandbox !== 'e2b') {
-    console.log(chalk.red('❌ Error: Only E2B sandbox is currently supported'));
-    console.log(chalk.yellow('💡 Available providers: e2b'));
+  if (sandbox !== 'e2b' && sandbox !== 'cloudflare') {
+    console.log(chalk.red('❌ Error: Invalid sandbox provider'));
+    console.log(chalk.yellow('💡 Available providers: e2b, cloudflare'));
     console.log(chalk.gray('   Example: --sandbox e2b --prompt "Create a web app"'));
+    console.log(chalk.gray('   Example: --sandbox cloudflare --prompt "Calculate factorial of 5"'));
     return;
   }
   
@@ -2542,28 +2508,247 @@ async function executeSandbox(options, targetDir) {
     // Ignore .env loading errors
   }
   
-  // Check for API keys (either from CLI parameters or environment variables)
-  const e2bKey = e2bApiKey || process.env.E2B_API_KEY;
+  // Check for API keys based on sandbox provider
   const anthropicKey = anthropicApiKey || process.env.ANTHROPIC_API_KEY;
-  
-  if (!e2bKey) {
-    console.log(chalk.red('❌ Error: E2B API key is required'));
-    console.log(chalk.yellow('💡 Options:'));
-    console.log(chalk.gray('   1. Set environment variable: E2B_API_KEY=your_key'));
-    console.log(chalk.gray('   2. Use CLI parameter: --e2b-api-key your_key'));
-    console.log(chalk.blue('   Get your key at: https://e2b.dev/dashboard'));
-    return;
+
+  if (sandbox === 'e2b') {
+    const e2bKey = e2bApiKey || process.env.E2B_API_KEY;
+
+    if (!e2bKey) {
+      console.log(chalk.red('❌ Error: E2B API key is required'));
+      console.log(chalk.yellow('💡 Options:'));
+      console.log(chalk.gray('   1. Set environment variable: E2B_API_KEY=your_key'));
+      console.log(chalk.gray('   2. Use CLI parameter: --e2b-api-key your_key'));
+      console.log(chalk.blue('   Get your key at: https://e2b.dev/dashboard'));
+      return;
+    }
+
+    if (!anthropicKey) {
+      console.log(chalk.red('❌ Error: Anthropic API key is required'));
+      console.log(chalk.yellow('💡 Options:'));
+      console.log(chalk.gray('   1. Set environment variable: ANTHROPIC_API_KEY=your_key'));
+      console.log(chalk.gray('   2. Use CLI parameter: --anthropic-api-key your_key'));
+      console.log(chalk.blue('   Get your key at: https://console.anthropic.com'));
+      return;
+    }
+
+    // Execute E2B sandbox
+    await executeE2BSandbox({ sandbox, agent, prompt, command, mcp, setting, hook, e2bKey, anthropicKey }, targetDir);
+
+  } else if (sandbox === 'cloudflare') {
+    if (!anthropicKey) {
+      console.log(chalk.red('❌ Error: Anthropic API key is required for Cloudflare sandbox'));
+      console.log(chalk.yellow('💡 Options:'));
+      console.log(chalk.gray('   1. Set environment variable: ANTHROPIC_API_KEY=your_key'));
+      console.log(chalk.gray('   2. Use CLI parameter: --anthropic-api-key your_key'));
+      console.log(chalk.blue('   Get your key at: https://console.anthropic.com'));
+      return;
+    }
+
+    // Execute Cloudflare sandbox
+    await executeCloudflareSandbox({ sandbox, agent, prompt, command, mcp, setting, hook, anthropicKey }, targetDir);
   }
-  
-  if (!anthropicKey) {
-    console.log(chalk.red('❌ Error: Anthropic API key is required'));
-    console.log(chalk.yellow('💡 Options:'));
-    console.log(chalk.gray('   1. Set environment variable: ANTHROPIC_API_KEY=your_key'));
-    console.log(chalk.gray('   2. Use CLI parameter: --anthropic-api-key your_key'));
-    console.log(chalk.blue('   Get your key at: https://console.anthropic.com'));
+}
+
+async function executeCloudflareSandbox(options, targetDir) {
+  const { agent, prompt, anthropicKey } = options;
+
+  console.log(chalk.blue('\n☁️  Cloudflare Sandbox Execution'));
+  console.log(chalk.cyan('═══════════════════════════════════════'));
+
+  if (agent) {
+    const agentList = agent.split(',');
+    if (agentList.length > 1) {
+      console.log(chalk.white(`📋 Agents (${agentList.length}):`));
+      agentList.forEach(a => console.log(chalk.yellow(`   • ${a.trim()}`)));
+    } else {
+      console.log(chalk.white(`📋 Agent: ${chalk.yellow(agent)}`));
+    }
+  } else {
+    console.log(chalk.white(`📋 Agent: ${chalk.yellow('default')}`));
+  }
+
+  const truncatedPrompt = prompt.length > 80 ? prompt.substring(0, 80) + '...' : prompt;
+  console.log(chalk.white(`💭 Prompt: ${chalk.cyan('"' + truncatedPrompt + '"')}`));
+  console.log(chalk.white(`🌐 Provider: ${chalk.green('Cloudflare Workers')}`));
+  console.log(chalk.gray('\n🔧 Execution details:'));
+  console.log(chalk.gray('   • Uses Claude AI for code generation'));
+  console.log(chalk.gray('   • Executes in isolated Cloudflare sandbox'));
+  console.log(chalk.gray('   • Global edge deployment for low latency\n'));
+
+  const inquirer = require('inquirer');
+
+  const { shouldExecute } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'shouldExecute',
+    message: 'Execute this prompt in Cloudflare sandbox?',
+    default: true
+  }]);
+
+  if (!shouldExecute) {
+    console.log(chalk.yellow('⏹️  Cloudflare sandbox execution cancelled by user.'));
     return;
   }
-  
+
+  try {
+    console.log(chalk.blue('🔮 Setting up Cloudflare sandbox environment...'));
+
+    const spinner = ora('Installing Cloudflare sandbox component...').start();
+
+    // Create .claude/sandbox/cloudflare directory
+    const sandboxDir = path.join(targetDir, '.claude', 'sandbox', 'cloudflare');
+    await fs.ensureDir(sandboxDir);
+
+    // Copy Cloudflare component files
+    const componentsDir = path.join(__dirname, '..', 'components', 'sandbox', 'cloudflare');
+
+    try {
+      if (await fs.pathExists(componentsDir)) {
+        console.log(chalk.gray('📦 Using local Cloudflare component files...'));
+
+        // Copy all files from cloudflare directory
+        await fs.copy(componentsDir, sandboxDir, {
+          overwrite: true,
+          filter: (src) => {
+            // Exclude node_modules and build artifacts
+            return !src.includes('node_modules') &&
+                   !src.includes('.wrangler') &&
+                   !src.includes('dist');
+          }
+        });
+      } else {
+        throw new Error('Cloudflare component files not found in package');
+      }
+    } catch (error) {
+      spinner.fail(`Failed to install Cloudflare component: ${error.message}`);
+      throw error;
+    }
+
+    spinner.succeed('Cloudflare sandbox component installed successfully');
+
+    // Check for Node.js
+    const nodeSpinner = ora('Checking Node.js environment...').start();
+
+    try {
+      const { spawn } = require('child_process');
+
+      // Check Node.js version
+      const checkNode = () => {
+        return new Promise((resolve) => {
+          const check = spawn('node', ['--version'], { stdio: 'pipe' });
+          check.on('close', (code) => resolve(code === 0));
+          check.on('error', () => resolve(false));
+        });
+      };
+
+      const nodeAvailable = await checkNode();
+      if (!nodeAvailable) {
+        nodeSpinner.fail('Node.js not found');
+        console.log(chalk.red('❌ Node.js 16.17.0+ is required for Cloudflare sandbox'));
+        console.log(chalk.yellow('💡 Please install Node.js and try again'));
+        console.log(chalk.blue('   Visit: https://nodejs.org'));
+        return;
+      }
+
+      nodeSpinner.succeed('Node.js environment ready');
+
+      // Install NPM dependencies
+      const depSpinner = ora('Installing Cloudflare dependencies...').start();
+
+      const npmInstall = spawn('npm', ['install'], {
+        cwd: sandboxDir,
+        stdio: 'pipe'
+      });
+
+      let npmOutput = '';
+      let npmError = '';
+
+      npmInstall.stdout.on('data', (data) => {
+        npmOutput += data.toString();
+      });
+
+      npmInstall.stderr.on('data', (data) => {
+        npmError += data.toString();
+      });
+
+      await new Promise((resolve, reject) => {
+        npmInstall.on('close', async (npmCode) => {
+          if (npmCode === 0) {
+            depSpinner.succeed('Cloudflare dependencies installed successfully');
+
+            // Execute using launcher
+            console.log(chalk.blue('🚀 Launching Cloudflare sandbox...'));
+            console.log(chalk.gray(`📝 Prompt: "${prompt.substring(0, 100)}${prompt.length > 100 ? '...' : ''}"`));
+
+            // Use ts-node or tsx to execute TypeScript launcher
+            const launcherPath = path.join(sandboxDir, 'launcher.ts');
+
+            console.log(chalk.blue('🚀 Starting Cloudflare sandbox execution...'));
+
+            const sandboxExecution = spawn('npx', [
+              'tsx',
+              launcherPath,
+              prompt,
+              agent || '',
+              anthropicKey,
+              'http://localhost:8787', // Local dev server URL
+              targetDir // Project root directory for file output
+            ], {
+              cwd: sandboxDir,
+              stdio: 'inherit',
+              timeout: 300000, // 5 minutes
+              env: {
+                ...process.env,
+                ANTHROPIC_API_KEY: anthropicKey
+              }
+            });
+
+            sandboxExecution.on('close', (code) => {
+              if (code === 0) {
+                console.log(chalk.green('🎉 Cloudflare sandbox execution completed successfully!'));
+                resolve();
+              } else if (code === null) {
+                console.log(chalk.yellow('⏹️  Sandbox execution was cancelled'));
+                resolve();
+              } else {
+                console.log(chalk.yellow(`⚠️  Sandbox execution finished with exit code ${code}`));
+                console.log(chalk.gray('💡 Check the output above for error details'));
+                resolve();
+              }
+            });
+
+            sandboxExecution.on('error', (error) => {
+              console.log(chalk.red(`❌ Error executing sandbox: ${error.message}`));
+              console.log(chalk.yellow('💡 Make sure you have set ANTHROPIC_API_KEY'));
+              reject(error);
+            });
+          } else {
+            depSpinner.fail('Failed to install Cloudflare dependencies');
+            console.log(chalk.red(`❌ npm install failed with exit code ${npmCode}`));
+            if (npmError) {
+              console.log(chalk.red('Error output:'));
+              console.log(chalk.gray(npmError.trim()));
+            }
+            reject(new Error('Failed to install dependencies'));
+          }
+        });
+      });
+
+    } catch (error) {
+      nodeSpinner.fail('Failed to check Node.js environment');
+      console.log(chalk.red(`❌ Error: ${error.message}`));
+      throw error;
+    }
+
+  } catch (error) {
+    console.log(chalk.red(`❌ Error setting up Cloudflare sandbox: ${error.message}`));
+    console.log(chalk.yellow('💡 Please check your internet connection and try again'));
+  }
+}
+
+async function executeE2BSandbox(options, targetDir) {
+  const { agent, prompt, command, mcp, setting, hook, e2bKey, anthropicKey } = options;
+
   // Sandbox execution confirmation
   console.log(chalk.blue('\n☁️ E2B Sandbox Execution'));
   console.log(chalk.cyan('═══════════════════════════════════════'));