claude-code-templates 1.29.2 → 1.29.4

package/README.md

@@ -5,6 +5,7 @@
 [![Sponsored by Z.AI](https://img.shields.io/badge/Sponsored%20by-Z.AI-2563eb?style=flat&logo=data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTEyIDJMMiAyMkgyMkwxMiAyWiIgZmlsbD0id2hpdGUiLz4KPC9zdmc+)](https://z.ai/subscribe?ic=8JVLJQFSKB&utm_source=github&utm_medium=badge&utm_campaign=readme)
 [![Claude for Open Source](https://img.shields.io/badge/Claude-Open%20Source%20Program-D97757?style=flat&logo=data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSIzIiBmaWxsPSJ3aGl0ZSIvPjwvc3ZnPg==)](https://claude.com/contact-sales/claude-for-oss)
 [![Neon Open Source Program](https://img.shields.io/badge/Neon-Open%20Source%20Program-00E599?style=flat)](https://get.neon.com/4eCjZDz)
+[![GitHub Sponsors](https://img.shields.io/badge/GitHub%20Sponsors-sponsor-EA4AAA?style=flat&logo=githubsponsors&logoColor=white)](https://github.com/sponsors/davila7)
 [![Buy Me A Coffee](https://img.shields.io/badge/Buy%20Me%20A%20Coffee-support-yellow?style=flat&logo=buy-me-a-coffee)](https://buymeacoffee.com/daniavila)
 [![GitHub stars](https://img.shields.io/github/stars/davila7/claude-code-templates.svg?style=social&label=Star)](https://github.com/davila7/claude-code-templates)
 
@@ -39,7 +40,8 @@
 
 **[Browse All Templates](https://aitmpl.com)** - Interactive web interface to explore and install 100+ agents, commands, settings, hooks, and MCPs.
 
-<img width="1049" height="855" alt="Screenshot 2025-08-19 at 08 09 24" src="https://github.com/user-attachments/assets/e3617410-9b1c-4731-87b7-a3858800b737" />
+<img width="1787" height="958" alt="image" src="https://github.com/user-attachments/assets/d84feaa4-f871-4843-bbee-42d8f51b2f21" />
+
 
 ## 🚀 Quick Installation
 
@@ -153,10 +155,12 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 - **🐛 Issues**: [GitHub Issues](https://github.com/davila7/claude-code-templates/issues)
 
 ## Stargazers over time
-[![Stargazers over time](https://starchart.cc/davila7/claude-code-templates.svg?variant=adaptive)](https://starchart.cc/davila7/claude-code-templates)
+[![Stargazers over time](docs/star-history.svg)](https://www.aitmpl.com/component/skill/git/star-history-chart)
 
 ---
 
 **⭐ Found this useful? Give us a star to support the project!**
 
-[![Buy Me A Coffee](https://img.buymeacoffee.com/button-api/?text=Buy%20me%20a%20coffee&slug=daniavila&button_colour=FFDD00&font_colour=000000&font_family=Cookie&outline_colour=000000&coffee_colour=ffffff)](https://buymeacoffee.com/daniavila)
+[![Sponsor on GitHub](https://img.shields.io/badge/Sponsor%20on%20GitHub-%E2%9D%A4-EA4AAA?style=for-the-badge&logo=githubsponsors&logoColor=white)](https://github.com/sponsors/davila7)
+
+[![Buy Me A Coffee](https://img.buymeacoffee.com/button-api/?text=Buy%20me%20a%20coffee&slug=daniavila&button_colour=FFDD00&font_colour=000000&font_family=Cookie&outline_colour=000000&coffee_colour=ffffff)](https://buymeacoffee.com/daniavila)

package/cli-tool/bin/create-claude-config.js

@@ -4,6 +4,7 @@ const { program } = require('commander');
 const chalk = require('chalk');
 const { createClaudeConfig } = require('../src/index');
 const { showBanner } = require('../src/tui');
+const { captureCliError } = require('../src/error-reporting');
 
 const pkg = require('../package.json');
 
@@ -37,6 +38,7 @@ program
   .option('--setting <setting>', 'install specific setting component (supports comma-separated values)')
   .option('--hook <hook>', 'install specific hook component (supports comma-separated values)')
   .option('--skill <skill>', 'install specific skill component (supports comma-separated values)')
+  .option('--loop <loop>', 'install specific loop component and its referenced components (supports comma-separated values)')
   .option('--workflow <workflow>', 'install workflow from hash (#hash) OR workflow YAML (base64 encoded) when used with --agent/--command/--mcp')
   .option('--prompt <prompt>', 'execute the provided prompt in Claude Code after installation or in sandbox')
   .option('--create-agent <agent>', 'create a global agent accessible from anywhere (e.g., customer-support)')
@@ -62,6 +64,7 @@ program
       await createClaudeConfig(options);
     } catch (error) {
       console.error(chalk.red('Error:'), error.message);
+      await captureCliError(error, { command: 'createClaudeConfig' });
       process.exit(1);
     }
   });

package/cli-tool/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-templates",
-  "version": "1.28.13",
+  "version": "1.29.4",
   "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": {

package/cli-tool/src/error-reporting.js

@@ -0,0 +1,158 @@
+/**
+ * ErrorReporting - Opt-in crash reporting to Sentry
+ *
+ * Unlike tracking-service.js (anonymous usage analytics, on by default),
+ * this NEVER sends anything unless the user explicitly opts in via
+ * CCT_ERROR_REPORTING=true. It always respects the existing opt-out flags
+ * (CCT_NO_TRACKING, CCT_NO_ANALYTICS, CI) so opt-out still wins over opt-in.
+ *
+ * No SDK dependency — sends directly to the Sentry envelope API via fetch(),
+ * matching the zero-dependency style used elsewhere in this project
+ * (cloudflare-workers/*\/sentry.js, dashboard/src/lib/api/error-tracking.ts).
+ */
+
+// Public DSN for the "aitmpl-cli" Sentry project. Sentry DSNs are not
+// secrets (they only allow sending events, not reading them) — this is the
+// same pattern most public telemetry SDKs use. Override with
+// CCT_SENTRY_DSN for local testing against a different project.
+const DEFAULT_SENTRY_DSN = 'https://1c1637a93ea6fb81e3edae3d039bdae0@o42738.ingest.us.sentry.io/4511679145312256';
+const SENTRY_DSN = process.env.CCT_SENTRY_DSN || DEFAULT_SENTRY_DSN;
+
+/**
+ * Whether error reporting is allowed to run at all.
+ * Opt-in required (CCT_ERROR_REPORTING=true), and opt-out always wins.
+ */
+function shouldReportErrors() {
+    if (process.env.CCT_ERROR_REPORTING !== 'true') {
+        return false;
+    }
+
+    if (process.env.CCT_NO_TRACKING === 'true' ||
+        process.env.CCT_NO_ANALYTICS === 'true' ||
+        process.env.CI === 'true') {
+        return false;
+    }
+
+    if (!SENTRY_DSN) {
+        if (process.env.CCT_DEBUG === 'true') {
+            console.debug('📊 CCT_ERROR_REPORTING is set but no DSN is configured; skipping.');
+        }
+        return false;
+    }
+
+    return true;
+}
+
+function parseDsn(dsn) {
+    try {
+        const url = new URL(dsn);
+        return {
+            publicKey: url.username,
+            host: url.host,
+            projectId: url.pathname.replace(/^\//, ''),
+        };
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Report a CLI error to Sentry. Opt-in only — see shouldReportErrors().
+ * Never throws; safe to call from any catch block.
+ *
+ * @param {Error} error
+ * @param {object} [context] - e.g. { command: 'install', componentType: 'agent' }
+ */
+async function captureCliError(error, context = {}) {
+    if (!shouldReportErrors()) {
+        return;
+    }
+
+    try {
+        const parsed = parseDsn(SENTRY_DSN);
+        if (!parsed) return;
+
+        const message = error instanceof Error ? error.message : String(error);
+        const stack = error instanceof Error ? error.stack : undefined;
+        const eventId = require('crypto').randomUUID().replace(/-/g, '');
+        const timestamp = new Date().toISOString();
+
+        const event = {
+            event_id: eventId,
+            timestamp,
+            platform: 'node',
+            logger: 'cli',
+            environment: 'production',
+            tags: {
+                cli_version: getCliVersion(),
+                node_version: process.version,
+                platform: process.platform,
+                ...context,
+            },
+            extra: context,
+            exception: {
+                values: [{
+                    type: error instanceof Error ? (error.name || 'Error') : 'Error',
+                    value: message,
+                    stacktrace: stack
+                        ? { frames: [{ filename: 'cli', function: 'anonymous', context_line: stack }] }
+                        : undefined,
+                }],
+            },
+        };
+
+        const envelopeHeader = JSON.stringify({ event_id: eventId, sent_at: timestamp });
+        const itemHeader = JSON.stringify({ type: 'event' });
+        const body = `${envelopeHeader}\n${itemHeader}\n${JSON.stringify(event)}\n`;
+
+        const endpoint = `https://${parsed.host}/api/${parsed.projectId}/envelope/`;
+        const authHeader = `Sentry sentry_version=7, sentry_client=aitmpl-cli/1.0, sentry_key=${parsed.publicKey}`;
+
+        if (typeof fetch !== 'function') {
+            // Node < 18 without global fetch — skip rather than pull in a dependency.
+            if (process.env.CCT_DEBUG === 'true') {
+                console.debug('📊 Error reporting requires Node 18+ (global fetch); skipping.');
+            }
+            return;
+        }
+
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 3000);
+
+        try {
+            await fetch(endpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-sentry-envelope',
+                    'X-Sentry-Auth': authHeader,
+                },
+                body,
+                signal: controller.signal,
+            });
+            if (process.env.CCT_DEBUG === 'true') {
+                console.debug('📊 Error reported to Sentry:', eventId);
+            }
+        } finally {
+            clearTimeout(timeoutId);
+        }
+    } catch (reportingError) {
+        // Error reporting must never crash the CLI or mask the original error.
+        if (process.env.CCT_DEBUG === 'true') {
+            console.debug('📊 Error reporting failed (non-critical):', reportingError.message);
+        }
+    }
+}
+
+function getCliVersion() {
+    try {
+        const path = require('path');
+        const fs = require('fs');
+        const packagePath = path.join(__dirname, '..', 'package.json');
+        const packageData = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+        return packageData.version || 'unknown';
+    } catch {
+        return 'unknown';
+    }
+}
+
+module.exports = { captureCliError, shouldReportErrors };

package/cli-tool/src/index.js

@@ -143,7 +143,7 @@ async function createClaudeConfig(options = {}) {
   }
   
   // Handle multiple components installation (new approach)
-  if (options.agent || options.command || options.mcp || options.setting || options.hook || options.skill) {
+  if (options.agent || options.command || options.mcp || options.setting || options.hook || options.skill || options.loop) {
     // If --workflow is used with components, treat it as YAML
     if (options.workflow) {
       options.yaml = options.workflow;
@@ -1652,6 +1652,123 @@ async function installIndividualSkill(skillName, targetDir, options) {
   }
 }
 
+/**
+ * Parse the `components:` frontmatter field of a loop into {type, path} refs.
+ * The field is a flat bracketed list of `type:path` tokens, e.g.
+ *   components: [agent:documentation/docs-architect, skill:git/create-pr]
+ */
+function parseLoopReferencedComponents(loopContent) {
+  const refs = [];
+  if (!loopContent || !loopContent.startsWith('---')) return refs;
+  const fmEnd = loopContent.indexOf('---', 3);
+  if (fmEnd === -1) return refs;
+  const frontmatter = loopContent.slice(3, fmEnd);
+  for (const line of frontmatter.split('\n')) {
+    if (!line.startsWith('components:')) continue;
+    const value = line.slice(line.indexOf(':') + 1).trim().replace(/^\[|\]$/g, '');
+    for (const token of value.split(',')) {
+      const trimmed = token.trim().replace(/^["']|["']$/g, '');
+      if (!trimmed) continue;
+      const sep = trimmed.indexOf(':');
+      if (sep === -1) continue;
+      const type = trimmed.slice(0, sep).trim();
+      const compPath = trimmed.slice(sep + 1).trim().replace(/\.(md|json)$/, '');
+      if (type && compPath) refs.push({ type, path: compPath });
+    }
+    break;
+  }
+  return refs;
+}
+
+/**
+ * Install a loop component (markdown) into .claude/loops/, then auto-install
+ * every component it references (agents, skills, hooks, commands, settings, mcps).
+ */
+async function installIndividualLoop(loopName, targetDir, options = {}) {
+  console.log(chalk.blue(`🔁 Installing loop: ${loopName}`));
+  const startTime = Date.now();
+
+  try {
+    const githubUrl = `https://raw.githubusercontent.com/davila7/claude-code-templates/main/cli-tool/components/loops/${loopName}.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(`❌ Loop "${loopName}" not found`));
+        trackingService.trackInstallationOutcome('loop', loopName, 'failure', { errorType: 'not_found', durationMs: Date.now() - startTime, batchId: options.batchId });
+        return false;
+      }
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    const loopContent = await response.text();
+
+    // Write the loop file to .claude/loops/ (flat, like agents)
+    const loopsDir = path.join(targetDir, '.claude', 'loops');
+    await fs.ensureDir(loopsDir);
+    const fileName = loopName.includes('/') ? loopName.split('/').pop() : loopName;
+    const targetFile = path.join(loopsDir, `${fileName}.md`);
+    await fs.writeFile(targetFile, loopContent, 'utf8');
+
+    if (!options.silent) {
+      console.log(chalk.green(`✅ Loop "${loopName}" installed successfully!`));
+      console.log(chalk.cyan(`📁 Installed to: ${path.relative(targetDir, targetFile)}`));
+    }
+
+    trackingService.trackDownload('loop', loopName, {
+      installation_type: 'individual_loop',
+      target_directory: path.relative(process.cwd(), targetDir),
+      source: 'github_main'
+    });
+
+    // Auto-install referenced components
+    const refs = parseLoopReferencedComponents(loopContent);
+    if (refs.length > 0) {
+      console.log(chalk.blue(`\n🧩 Installing ${refs.length} referenced component(s) for this loop...`));
+      const refOptions = { ...options, silent: true };
+      for (const ref of refs) {
+        try {
+          switch (ref.type) {
+            case 'agent':
+              await installIndividualAgent(ref.path, targetDir, refOptions);
+              break;
+            case 'command':
+              await installIndividualCommand(ref.path, targetDir, refOptions);
+              break;
+            case 'skill':
+              await installIndividualSkill(ref.path, targetDir, refOptions);
+              break;
+            case 'hook':
+              await installIndividualHook(ref.path, targetDir, refOptions);
+              break;
+            case 'setting':
+              await installIndividualSetting(ref.path, targetDir, refOptions);
+              break;
+            case 'mcp':
+              await installIndividualMCP(ref.path, targetDir, refOptions);
+              break;
+            default:
+              console.log(chalk.yellow(`   ⚠️  Unknown referenced component type: ${ref.type}:${ref.path}`));
+              continue;
+          }
+          console.log(chalk.green(`   ✓ ${ref.type}: ${ref.path}`));
+        } catch (refError) {
+          console.log(chalk.yellow(`   ⚠️  Could not install ${ref.type}:${ref.path} (${refError.message})`));
+        }
+      }
+    }
+
+    trackingService.trackInstallationOutcome('loop', loopName, 'success', { durationMs: Date.now() - startTime, batchId: options.batchId });
+    return true;
+
+  } catch (error) {
+    console.log(chalk.red(`❌ Error installing loop: ${error.message}`));
+    trackingService.trackInstallationOutcome('loop', loopName, 'failure', { errorType: 'network_error', errorMessage: error.message, durationMs: Date.now() - startTime, batchId: options.batchId });
+    return false;
+  }
+}
+
 /**
  * Install multiple components with optional YAML workflow
  */
@@ -1666,7 +1783,8 @@ async function installMultipleComponents(options, targetDir) {
       mcps: [],
       settings: [],
       hooks: [],
-      skills: []
+      skills: [],
+      loops: []
     };
     
     // Parse comma-separated values for each component type
@@ -1700,7 +1818,12 @@ async function installMultipleComponents(options, targetDir) {
       components.skills = skillsInput.split(',').map(s => s.trim()).filter(s => s);
     }
 
-    const totalComponents = components.agents.length + components.commands.length + components.mcps.length + components.settings.length + components.hooks.length + components.skills.length;
+    if (options.loop) {
+      const loopsInput = Array.isArray(options.loop) ? options.loop.join(',') : options.loop;
+      components.loops = loopsInput.split(',').map(l => l.trim()).filter(l => l);
+    }
+
+    const totalComponents = components.agents.length + components.commands.length + components.mcps.length + components.settings.length + components.hooks.length + components.skills.length + components.loops.length;
     
     if (totalComponents === 0) {
       console.log(chalk.yellow('⚠️  No components specified to install.'));
@@ -1714,13 +1837,15 @@ async function installMultipleComponents(options, targetDir) {
     console.log(chalk.gray(`   Settings: ${components.settings.length}`));
     console.log(chalk.gray(`   Hooks: ${components.hooks.length}`));
     console.log(chalk.gray(`   Skills: ${components.skills.length}`));
-    
+    console.log(chalk.gray(`   Loops: ${components.loops.length}`));
+
     // Counter for successfully installed components
     let successfullyInstalled = 0;
     
     // Ask for installation locations once for configuration components (if any exist and not in silent mode)
     let sharedInstallLocations = ['local']; // default
-    const hasSettingsOrHooks = components.settings.length > 0 || components.hooks.length > 0;
+    // Loops can pull in settings/hooks via their referenced components, so prompt for a location when loops are present too.
+    const hasSettingsOrHooks = components.settings.length > 0 || components.hooks.length > 0 || components.loops.length > 0;
     
     if (hasSettingsOrHooks && !options.yes) {
       console.log(chalk.blue('\n📍 Choose installation locations for configuration components:'));
@@ -1812,6 +1937,18 @@ async function installMultipleComponents(options, targetDir) {
       if (skillSuccess) successfullyInstalled++;
     }
 
+    // Install loops (auto-installs their referenced components)
+    for (const loop of components.loops) {
+      console.log(chalk.gray(`   Installing loop: ${loop}`));
+      const loopSuccess = await installIndividualLoop(loop, targetDir, {
+        ...options,
+        silent: true,
+        sharedInstallLocations: sharedInstallLocations,
+        batchId
+      });
+      if (loopSuccess) successfullyInstalled++;
+    }
+
     // Handle YAML workflow if provided
     if (options.yaml) {
       console.log(chalk.blue('\n📄 Processing workflow YAML...'));

package/cli-tool/src/sandbox-server.js

@@ -9,6 +9,12 @@ const fs = require('fs');
 const app = express();
 const PORT = process.env.PORT || 3444;
 
+// Platform-aware command names. Now that spawns run without `shell: true`,
+// Windows needs the `.cmd` shim to resolve npm-installed executables (bare
+// 'npx'/'claude' would fail with ENOENT on win32).
+const NPX_CMD = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+const CLAUDE_CMD = process.platform === 'win32' ? 'claude.cmd' : 'claude';
+
 // Load .env file from current working directory (where user runs the command)
 function loadEnvFile() {
     const envPath = path.join(process.cwd(), '.env');
@@ -47,11 +53,26 @@ function loadEnvFile() {
 // Load environment variables on startup
 const hasApiKeys = loadEnvFile();
 
-// Simple CORS middleware
+// CORS middleware — restrict to the local Studio UI origin only.
+// A wildcard (`*`) origin combined with the command-executing endpoints below
+// lets any web page the developer visits drive requests into this server
+// (drive-by RCE). Only allow the same-origin UI served from localhost:PORT.
+const ALLOWED_ORIGINS = new Set([
+    `http://localhost:${PORT}`,
+    `http://127.0.0.1:${PORT}`,
+]);
 app.use((req, res, next) => {
-    res.header('Access-Control-Allow-Origin', '*');
+    const origin = req.headers.origin;
+    if (origin && ALLOWED_ORIGINS.has(origin)) {
+        res.header('Access-Control-Allow-Origin', origin);
+    }
+    res.header('Vary', 'Origin');
     res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
     res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
+    // Reject cross-origin requests outright for the state-changing endpoints.
+    if (origin && !ALLOWED_ORIGINS.has(origin)) {
+        return res.status(403).json({ success: false, error: 'Cross-origin request rejected' });
+    }
     if (req.method === 'OPTIONS') {
         res.sendStatus(200);
     } else {
@@ -199,22 +220,31 @@ app.get('/api/tasks', (req, res) => {
 // API endpoint to install agent
 app.post('/api/install-agent', async (req, res) => {
     const { agentName } = req.body;
-    
+
     if (!agentName) {
         return res.status(400).json({
             success: false,
             error: 'Agent name is required'
         });
     }
-    
+
+    // SECURITY: agent names are `category/name` slugs. Reject anything else so a
+    // value like "x; rm -rf ~" can never reach the child process.
+    if (!/^[A-Za-z0-9._/-]+$/.test(agentName)) {
+        return res.status(400).json({
+            success: false,
+            error: 'Invalid agent name'
+        });
+    }
+
     try {
         console.log(chalk.blue('🔧 Installing agent:'), chalk.cyan(agentName));
-        
-        // Use the CLI tool to install the agent
-        const child = spawn('npx', ['claude-code-templates@latest', '--agent', agentName, '--yes'], {
+
+        // SECURITY: shell:false (default) keeps agentName as a single argv entry —
+        // no shell parses it, so metacharacters cannot inject commands.
+        const child = spawn(NPX_CMD, ['claude-code-templates@latest', '--agent', agentName, '--yes'], {
             cwd: process.cwd(),
-            stdio: ['pipe', 'pipe', 'pipe'],
-            shell: true
+            stdio: ['pipe', 'pipe', 'pipe']
         });
         
         let output = [];
@@ -276,11 +306,17 @@ async function checkAndInstallAgent(agentName, task) {
     
     task.output.push(`🔧 Agent ${agentName} not found locally. Installing...`);
     
+    // SECURITY: reject anything that is not a plain `category/name` slug.
+    if (!/^[A-Za-z0-9._/-]+$/.test(agentName)) {
+        task.output.push(`❌ Invalid agent name: ${agentName}`);
+        return Promise.resolve(false);
+    }
+
     return new Promise((resolve, reject) => {
-        const child = spawn('npx', ['claude-code-templates@latest', '--agent', agentName, '--yes'], {
+        // SECURITY: shell:false (default) — agentName stays a single argv entry.
+        const child = spawn(NPX_CMD, ['claude-code-templates@latest', '--agent', agentName, '--yes'], {
             cwd: process.cwd(),
-            stdio: ['pipe', 'pipe', 'pipe'],
-            shell: true
+            stdio: ['pipe', 'pipe', 'pipe']
         });
         
         child.stdout.on('data', (data) => {
@@ -460,15 +496,18 @@ async function executeLocalTask(task) {
             finalPrompt = `As a ${task.agent.replace('-', ' ')}, ${task.prompt}`;
         }
         
-        // Execute Claude Code locally with just the prompt
-        const child = spawn('claude', [finalPrompt], {
+        // Execute Claude Code locally with just the prompt.
+        // SECURITY: never run through a shell. With shell:true, Node joins argv into
+        // a single `sh -c` string and the attacker-controlled prompt is parsed by the
+        // shell (command injection). shell:false keeps finalPrompt as a single argv[1].
+        // Windows: resolve claude.cmd explicitly (CLAUDE_CMD) instead of re-enabling shell:true.
+        const child = spawn(CLAUDE_CMD, [finalPrompt], {
             cwd: process.cwd(),
             stdio: ['ignore', 'pipe', 'pipe'], // Ignore stdin to prevent hanging
             env: {
                 ...process.env,
                 PATH: process.env.PATH
             },
-            shell: true, // Use shell to find claude command
             timeout: 300000 // 5 minute timeout
         });
         
@@ -558,8 +597,9 @@ async function executeLocalTask(task) {
     }
 }
 
-// Start server
-app.listen(PORT, () => {
+// Start server — bind to loopback only. This is a local developer tool that
+// executes commands; binding to 0.0.0.0 exposes RCE to the whole LAN.
+app.listen(PORT, '127.0.0.1', () => {
     console.log(chalk.blue('\\n🎨 Claude Code Studio Server'));
     console.log(chalk.cyan('═══════════════════════════════════════'));
     console.log(chalk.green(`🚀 Server running on http://localhost:${PORT}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-templates",
-  "version": "1.29.2",
+  "version": "1.29.4",
   "description": "Component templates and tracking system for Claude Code",
   "main": "cli-tool/src/index.js",
   "bin": {