codymaster 4.4.5 → 4.5.2

package/scripts/security-fixer.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+/**
+ * 🛠️ CodyMaster Security Fixer
+ * Automated remediation for security vulnerabilities and secret leaks.
+ * 
+ * Usage:
+ *   node scripts/security-fixer.js          # Audit only
+ *   node scripts/security-fixer.js --fix    # Audit + Fix
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const DANGEROUS_PATTERNS = [
+  { name: 'Service Key Variable', regex: /(?:SERVICE_KEY|SERVICE_ROLE)\s*[=:]\s*['\"][a-zA-Z0-9._\/-]{20,}/g },
+  { name: 'Anon Key Variable', regex: /ANON_KEY\s*[=:]\s*['\"][a-zA-Z0-9._\/-]{20,}/g },
+  { name: 'Private Key Block', regex: /-----BEGIN\s+(RSA|EC|DSA|OPENSSH)?\s*PRIVATE KEY-----/g },
+  { name: 'JWT Token', regex: /eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}/g },
+  { name: 'Generic API Key', regex: /(?:api[_-]?key|api[_-]?secret|access[_-]?token)\s*[=:]\s*['\"][a-zA-Z0-9\/+=]{20,}['\"/]/gi },
+  { name: 'AWS Key', regex: /AKIA[0-9A-Z]{16}/g },
+  { name: 'Slack Token', regex: /xox[baprs]-[0-9a-zA-Z-]{10,}/g },
+  { name: 'GitHub Token', regex: /gh[ps]_[a-zA-Z0-9]{36,}/g },
+  { name: 'Stripe Key', regex: /[sr]k_(test|live)_[a-zA-Z0-9]{20,}/g },
+  { name: 'DB Password', regex: /(?:DB_PASSWORD|DATABASE_URL)\s*[=:]\s*['\"][^'\"]{8,}/gi },
+];
+
+const SKIP_DIRS = ['node_modules', '.git', 'dist', '.wrangler', '.next', 'coverage', '.cm'];
+const SCAN_EXTS = ['.js', '.ts', '.jsx', '.tsx', '.json', '.toml', '.yaml', '.yml',
+                    '.env', '.cfg', '.conf', '.ini', '.md', '.html', '.jsonc'];
+
+const args = process.argv.slice(2);
+const shouldFix = args.includes('--fix');
+const isDryRun = args.includes('--dry-run');
+
+let findings = [];
+
+function scanDir(dir) {
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (SKIP_DIRS.includes(entry.name)) continue;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        scanDir(fullPath);
+      } else if (entry.isFile() && SCAN_EXTS.some(ext => entry.name.endsWith(ext))) {
+        const content = fs.readFileSync(fullPath, 'utf-8');
+        let fileStatus = { file: fullPath, issues: [] };
+        
+        for (const pattern of DANGEROUS_PATTERNS) {
+          const matches = content.match(pattern.regex);
+          if (matches) {
+            fileStatus.issues.push({ pattern: pattern.name, matches: matches });
+          }
+        }
+        
+        if (fileStatus.issues.length > 0) {
+          findings.push(fileStatus);
+        }
+      }
+    }
+  } catch (e) {}
+}
+
+console.log('🔍 Starting Security Audit...');
+scanDir('.');
+
+if (findings.length === 0) {
+  console.log('✅ No vulnerabilities detected.');
+  process.exit(0);
+}
+
+console.error(`❌ Found ${findings.length} files with issues:`);
+findings.forEach(f => {
+  console.error(`  ⚠ ${f.file}`);
+  f.issues.forEach(i => console.error(`    - ${i.pattern}: ${i.matches.length} matches`));
+});
+
+if (shouldFix) {
+  console.log('\n🔧 Applying Automated Remediation...');
+  findings.forEach(f => {
+    let content = fs.readFileSync(f.file, 'utf-8');
+    let originalContent = content;
+
+    f.issues.forEach(issue => {
+      issue.matches.forEach(match => {
+        const half = Math.floor(match.length / 2);
+        const prefix = match.substring(0, Math.max(4, match.length - 12));
+        const masked = prefix + '*'.repeat(match.length - prefix.length);
+        content = content.replace(match, masked);
+      });
+    });
+
+    if (content !== originalContent) {
+      if (isDryRun) {
+        console.log(`  [DRY RUN] Would mask secrets in ${f.file}`);
+      } else {
+        fs.writeFileSync(f.file, content);
+        console.log(`  ✅ Masked secrets in ${f.file}`);
+      }
+    }
+
+    // Auto-gitignore check
+    if (!SKIP_DIRS.includes(path.basename(f.file))) {
+        const gitIgnorePath = path.join(path.dirname(f.file), '.gitignore');
+        const fileName = path.basename(f.file);
+        if (fs.existsSync(gitIgnorePath)) {
+            const gitIgnoreContent = fs.readFileSync(gitIgnorePath, 'utf-8');
+            if (!gitIgnoreContent.includes(fileName)) {
+                if (isDryRun) {
+                    console.log(`  [DRY RUN] Would add ${fileName} to ${gitIgnorePath}`);
+                } else {
+                    fs.appendFileSync(gitIgnorePath, `\n${fileName}\n`);
+                    console.log(`  ✅ Added ${fileName} to .gitignore`);
+                }
+            }
+        }
+    }
+  });
+
+  // Dependency check
+  console.log('\n📦 Checking for dependency vulnerabilities...');
+  try {
+    execSync('npm audit fix', { stdio: 'inherit' });
+  } catch (e) {
+    console.error('  ⚠️ npm audit fix failed or found issues that require manual attention.');
+  }
+} else {
+  console.log('\n💡 Tip: Run with --fix to apply automated remediation.');
+}
+
+// Generate Report
+const report = {
+  timestamp: new Date().toISOString(),
+  summary: {
+    total_files_scanned: findings.length, // approximation of issues
+    total_issues: findings.reduce((acc, f) => acc + f.issues.length, 0),
+  },
+  findings: findings
+};
+
+fs.writeFileSync('security-report.json', JSON.stringify(report, null, 2));
+console.log('\n📊 Security report generated: security-report.json');

package/scripts/security-scan.js

@@ -0,0 +1,55 @@
+const fs = require('fs');
+const path = require('path');
+
+const DANGEROUS_PATTERNS = [
+  { name: 'Service Key Variable', regex: /(?:SERVICE_KEY|SERVICE_ROLE)\s*[=:]\s*['\"][a-zA-Z0-9._\/-]{20,}/g },
+  { name: 'Anon Key Variable', regex: /ANON_KEY\s*[=:]\s*['\"][a-zA-Z0-9._\/-]{20,}/g },
+  { name: 'Private Key Block', regex: /-----BEGIN\s+(RSA|EC|DSA|OPENSSH)?\s*PRIVATE KEY-----/g },
+  { name: 'JWT Token', regex: /eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}/g },
+  { name: 'Generic API Key', regex: /(?:api[_-]?key|api[_-]?secret|access[_-]?token)\s*[=:]\s*['\"][a-zA-Z0-9\/+=]{20,}['\"/]/gi },
+  { name: 'AWS Key', regex: /AKIA[0-9A-Z]{16}/g },
+  { name: 'Slack Token', regex: /xox[baprs]-[0-9a-zA-Z-]{10,}/g },
+  { name: 'GitHub Token', regex: /gh[ps]_[a-zA-Z0-9]{36,}/g },
+  { name: 'Stripe Key', regex: /[sr]k_(test|live)_[a-zA-Z0-9]{20,}/g },
+  { name: 'DB Password', regex: /(?:DB_PASSWORD|DATABASE_URL)\s*[=:]\s*['\"][^'\"]{8,}/gi },
+];
+
+const SKIP_DIRS = ['node_modules', '.git', 'dist', '.wrangler', '.next', 'coverage'];
+const SCAN_EXTS = ['.js', '.ts', '.jsx', '.tsx', '.json', '.toml', '.yaml', '.yml',
+                    '.env', '.cfg', '.conf', '.ini', '.md', '.html', '.jsonc'];
+
+let findings = [];
+
+function scanDir(dir) {
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (SKIP_DIRS.includes(entry.name)) continue;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        scanDir(fullPath);
+      } else if (entry.isFile() && SCAN_EXTS.some(ext => entry.name.endsWith(ext))) {
+        const content = fs.readFileSync(fullPath, 'utf-8');
+        for (const pattern of DANGEROUS_PATTERNS) {
+          const matches = content.match(pattern.regex);
+          if (matches) {
+            findings.push({ file: fullPath, pattern: pattern.name, count: matches.length });
+          }
+        }
+      }
+    }
+  } catch (e) { /* skip unreadable dirs */ }
+}
+
+scanDir('.');
+
+if (findings.length > 0) {
+  console.error('❌ SECRET SCAN FOUND ' + findings.length + ' POTENTIAL ISSUES:');
+  findings.forEach(f => {
+    console.error('  ⚠ ' + f.file + ' — ' + f.pattern + ' (' + f.count + ' match(es))');
+  });
+  console.error('');
+  process.exit(1);
+} else {
+  console.log('✅ Repo scan: no secrets detected');
+}

package/scripts/test-gemini.js

@@ -0,0 +1,13 @@
+const { exec, spawn } = require('child_process');
+
+// Method 1: exec
+exec('gemini -y -p "Hello!"', (err, stdout, stderr) => {
+    console.log('EXEC Result:', stdout || stderr);
+});
+
+// Method 2: spawn
+const child = spawn('gemini', ['-y', '-p', 'Hello!']);
+let out = '';
+child.stdout.on('data', d => out += d);
+child.stderr.on('data', d => out += d);
+child.on('close', () => console.log('SPAWN Result:', out));

package/scripts/todo-bridge.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+/**
+ * cm-dashboard Todo Bridge — Phase 1 (Claude Code PostToolUse hook)
+ *
+ * Invoked by Claude Code as a PostToolUse hook on every TodoWrite event.
+ * Reads the hook payload from stdin, maps todos to dashboard tasks,
+ * and POSTs each to /api/tasks/auto-sync.
+ *
+ * Install:
+ *   cp scripts/todo-bridge.js ~/.claude/scripts/todo-bridge.js
+ *
+ * Hook config (~/.claude/settings.json):
+ *   {
+ *     "hooks": {
+ *       "PostToolUse": [{
+ *         "matcher": "TodoWrite",
+ *         "hooks": [{ "type": "command", "command": "node ~/.claude/scripts/todo-bridge.js" }]
+ *       }]
+ *     }
+ *   }
+ */
+
+'use strict';
+
+const http = require('http');
+const path = require('path');
+
+const DASHBOARD_PORT = process.env.CM_DASHBOARD_PORT || 6969;
+
+// Map TodoWrite status → dashboard column
+const STATUS_MAP = {
+  pending: 'backlog',
+  in_progress: 'in-progress',
+  completed: 'done',
+};
+
+// Map TodoWrite priority → dashboard priority
+const PRIORITY_MAP = {
+  high: 'high',
+  medium: 'medium',
+  low: 'low',
+  urgent: 'urgent',
+};
+
+function postJson(payload) {
+  return new Promise((resolve) => {
+    const body = JSON.stringify(payload);
+    const req = http.request(
+      {
+        hostname: 'localhost',
+        port: DASHBOARD_PORT,
+        path: '/api/tasks/auto-sync',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body),
+        },
+      },
+      (res) => {
+        res.resume(); // drain
+        resolve(res.statusCode);
+      }
+    );
+    req.on('error', () => resolve(null)); // silent — dashboard may not be running
+    req.write(body);
+    req.end();
+  });
+}
+
+async function main() {
+  // Read stdin
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const raw = Buffer.concat(chunks).toString('utf8').trim();
+  if (!raw) process.exit(0);
+
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    process.exit(0); // not JSON — ignore
+  }
+
+  // Only handle TodoWrite
+  if (payload.tool_name !== 'TodoWrite') process.exit(0);
+
+  const todos = payload.tool_input?.todos;
+  if (!Array.isArray(todos) || todos.length === 0) process.exit(0);
+
+  const sessionId = payload.session_id || 'unknown';
+  const cwd = payload.cwd || process.cwd();
+  const projectName = path.basename(cwd);
+
+  // Fire all syncs concurrently
+  await Promise.all(
+    todos.map((todo) => {
+      const column = STATUS_MAP[todo.status] || 'backlog';
+      return postJson({
+        conversationId: `${sessionId}:${todo.id}`,
+        title: todo.content,
+        status: column,
+        agent: 'claude-code',
+        priority: PRIORITY_MAP[todo.priority] || 'medium',
+        projectName,
+      });
+    })
+  );
+
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0)); // always silent

package/skills/_shared/helpers.md

@@ -7,20 +7,56 @@
 
 ## #Load-Working-Memory
 
-Before executing any significant action, ALWAYS:
-
-1. **Read** `.cm/CONTINUITY.md` → understand current state, Active Goal, Next Actions
-2. **Run Memory Audit** — decay check + conflict detection + integrity scan (see `cm-continuity`)
-3. **Scope-filter learnings** — if working on module X:
-   - Load from `.cm/learnings.json` ONLY where `scope == "global"` or `scope == "module:X"`
-   - **NEVER** load `status = "invalidated"` (proven wrong — skip entirely)
-   - **CAUTION** with `status = "corrected"` (was wrong, verify before applying)
-   - **TRUST** high `reinforceCount` + recent `lastRelevant`
-   - **VERIFY** `reinforceCount = 0` + old `lastRelevant` (low confidence)
-   - SKIP learnings for other modules (reduces noise + saves tokens)
-4. **Check** "Next Actions" — pick up where you left off
-
-> **Token savings:** Scope-filtered reading loads ~250 tokens instead of ~2,500.
+Before executing any significant action, ALWAYS load context in this order (cheapest → richest):
+
+### Step 1 — Check context bus (free, ~50 tokens)
+```
+Read .cm/context-bus.json (or: cm continuity bus)
+→ If active pipeline found:
+    - Note current_step and pipeline name
+    - Read shared_context to see what upstream skills already produced
+    - SKIP re-doing any work already recorded in shared_context
+→ If no bus: fresh session, proceed normally
+```
+
+### Step 2 — Load L0 indexes first (~600 tokens total)
+```
+Read .cm/learnings-index.md   (~100 tokens) — IDs + 1-line summaries
+Read .cm/skeleton-index.md    (~500 tokens) — modules, entry points, config files
+
+→ If a specific learning ID looks relevant → resolve cm://memory/learnings/{id} for full detail
+→ If a specific module looks relevant   → resolve cm://resources/skeleton at L2 for full detail
+→ Otherwise: L0 is sufficient — DO NOT load full files
+```
+
+### Step 3 — Scope-filter learnings (only if L0 flags relevant entries)
+```
+Query: cm_query(scope="learnings", query="{current module or error type}", limit=5)
+   OR read .cm/memory/learnings.json filtered to scope == "global" | "module:X"
+
+Rules:
+  NEVER  load status = "invalidated"   (proven wrong)
+  CAUTION status = "corrected"         (verify before applying)
+  TRUST  high reinforceCount + recent lastRelevant
+  SKIP   learnings for other modules (noise + wasted tokens)
+```
+
+### Step 4 — Check working memory
+```
+Read .cm/CONTINUITY.md → Active Goal, Next Actions, current phase
+Run Memory Audit (decay + conflict detection) — see cm-continuity
+```
+
+### Step 5 — Token budget check (before injecting large context)
+```
+cm continuity budget  (or: loadBudget + checkBudget in code)
+→ If category is over soft limit → use L0/L1 depth instead of L2
+→ Never inject full skeleton (20KB) when skeleton-index.md (~2KB) suffices
+```
+
+> **Token savings v5:** Full cold load ~3,200 tokens → Smart Spine load ~700 tokens (78% reduction).
+> L0 indexes + context bus + scope filter make this possible.
+> Only escalate to L2 when L0/L1 explicitly flag the need.
 
 ---
 

package/skills/cm-autopilot/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: cm-autopilot
+description: Easy-to-use conversational CLI (Claude Code style) for non-technical users to spawn parallel AI tasks supervised by a visual web dashboard.
+---
+
+# CM AutoPilot CLI — Conversational Task Supervisor
+
+> **Just talk to it. It plans, splits, and watches parallel tasks for you.**
+
+## What it does
+- Provides a conversational CLI interface using `rich` and `prompt_toolkit`.
+- Translates user intent into multiple parallel tasks.
+- Integrates with `cm-content-factory`'s Dashboard (`localhost:5050`) for a visual way to track multi-threading.
+- Allows non-technical users to utilize the Cody Master skill set effortlessly.
+
+## Requirements
+- Python 3.9+
+- `rich`
+- `prompt_toolkit`
+
+## How to run
+
+1. Launch the conversational CLI:
+   ```bash
+   python3 skills/cm-autopilot/scripts/autopilot.py
+   ```
+2. The CLI will ask what you want to do. Explain your complex request (e.g., "Dịch 10 bài báo sang tiếng anh", "Research 5 competitors").
+3. The AutoPilot will generate tasks and push them into the Queue.
+4. AutoPilot will automatically start the visual Dashboard at `http://localhost:5050` so you can watch your jobs execute in parallel.

package/skills/cm-autopilot/scripts/autopilot.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""
+AutoPilot CLI — Conversational Interface for Cody Master Skills
+
+This is a Claude Code-style interactive CLI. It talks to the user,
+understands their goals, creates a plan, and then parallelizes
+tasks into the Agent Dispatcher (queue) while launching the Visual
+Dashboard for easy tracking.
+"""
+
+import sys
+import time
+import os
+import subprocess
+import threading
+from pathlib import Path
+
+# Add cm-content-factory to sys.path to reuse the dispatcher and state manager
+SKILLS_DIR = Path(__file__).resolve().parent.parent.parent
+CF_SCRIPTS = SKILLS_DIR / "cm-content-factory" / "scripts"
+sys.path.append(str(CF_SCRIPTS))
+
+try:
+    from agent_dispatcher import AgentDispatcher
+    from state_manager import StateManager
+    from rich.console import Console
+    from rich.markdown import Markdown
+    from rich.panel import Panel
+    from rich.prompt import Prompt
+    from rich.progress import Progress, SpinnerColumn, TextColumn
+except ImportError:
+    print("Please install requirements: pip install rich prompt_toolkit")
+    sys.exit(1)
+
+console = Console()
+project_root = Path(os.getcwd()).resolve()
+
+dispatcher = AgentDispatcher(str(project_root))
+state_mgr = StateManager(str(project_root))
+
+DASHBOARD_PROCESS = None
+
+def start_dashboard():
+    """Starts the cm-content-factory dashboard server in the background."""
+    global DASHBOARD_PROCESS
+    dashboard_script = CF_SCRIPTS / "dashboard_server.py"
+    if dashboard_script.exists():
+        DASHBOARD_PROCESS = subprocess.Popen(
+            [sys.executable, str(dashboard_script), "--port", "5050", "--no-open"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL
+        )
+        return True
+    return False
+
+def show_welcome():
+    console.print(Panel.fit(
+        "[bold cyan]🚀 Welcome to Cody Master AutoPilot[/bold cyan]\n"
+        "[dim]Your conversational AI orchestrator.[/dim]\n\n"
+        "Tell me what you want to achieve, and I will plan, split,\n"
+        "and execute parallel tasks for you. No technical skills required.",
+        title="AutoPilot v1.0", border_style="cyan"
+    ))
+
+def mock_llm_task_parser(prompt: str) -> list:
+    """
+    Mock parser that simulates an LLM breaking down a user request 
+    into parallel tasks based on keywords.
+    """
+    tasks = []
+    lower_prompt = prompt.lower()
+    
+    if "dịch" in lower_prompt or "translate" in lower_prompt:
+        # Example: Dịch 5 bài báo
+        count = 5
+        for w in lower_prompt.split():
+            if w.isdigit():
+                count = int(w)
+                break
+        for i in range(1, count + 1):
+            tasks.append({
+                "id": f"translate-{int(time.time()*100)}-{i}",
+                "type": "translate",
+                "meta": {"file": f"article_{i}.txt", "target_lang": "en"}
+            })
+    elif "research" in lower_prompt or "tìm hiểu" in lower_prompt:
+        tasks.append({"id": f"res-1", "type": "research", "meta": {"topic": "Market Trends"}})
+        tasks.append({"id": f"res-2", "type": "research", "meta": {"topic": "Competitors"}})
+        tasks.append({"id": f"res-3", "type": "research", "meta": {"topic": "Keywords"}})
+    else:
+        # Generic fallback
+        tasks.append({"id": f"task-1", "type": "general", "meta": {"instruction": prompt}})
+        tasks.append({"id": f"task-2", "type": "general", "meta": {"instruction": "Review output"}})
+        
+    return tasks
+
+def background_worker(worker_id: str):
+    """A simple worker loop simulating parallel execution of tasks."""
+    state_mgr.register_agent(worker_id, "autopilot_worker")
+    while True:
+        task = dispatcher.claim_next(worker_id)
+        if not task:
+            time.sleep(2)
+            continue
+        
+        # Log active phase
+        phase_map = {"translate": "write", "research": "extract", "general": "plan"}
+        phase = phase_map.get(task["type"], "write")
+        state_mgr.update_phase(phase, "running", progress=0.1)
+        state_mgr.add_task(task["id"], "running", task["meta"])
+        
+        # Simulate work
+        dispatcher.heartbeat(worker_id, task["id"])
+        time.sleep(3) # Heavy work
+        
+        state_mgr.add_task(task["id"], "done", task["meta"])
+        dispatcher.complete(task["id"], worker_id, {"result": "success"})
+        state_mgr.log_event("info", f"[{worker_id}] Completed task: {task['id']}")
+        
+        # Check if phase done
+        q = dispatcher.get_queue()
+        if q["queued"] == 0 and q["claimed"] == 0:
+            state_mgr.update_phase(phase, "done", progress=1.0)
+
+def main_loop():
+    # Reset queue and state for fresh start
+    dispatcher.reset()
+    state_mgr.reset()
+    
+    # Start dashboard
+    if start_dashboard():
+        state_mgr.log_event("info", "Dashboard Server started on port 5050")
+    
+    # Start background workers (simulating multiple parallel agents)
+    for i in range(3):
+        t = threading.Thread(target=background_worker, args=(f"worker-{i+1}",), daemon=True)
+        t.start()
+        
+    try:
+        while True:
+            user_input = Prompt.ask("\n[bold green]You[/bold green]")
+            if user_input.lower() in ("exit", "quit", "q"):
+                break
+            
+            if not user_input.strip():
+                continue
+                
+            with Progress(
+                SpinnerColumn(), 
+                TextColumn("[progress.description]{task.description}"), 
+                transient=True
+            ) as progress:
+                progress.add_task("Thinking and Planning...", total=None)
+                time.sleep(1.5) # Simulate LLM thinking
+                tasks = mock_llm_task_parser(user_input)
+                
+            console.print(f"[bold blue]AutoPilot:[/bold blue] I've analyzed your request and created [bold]{len(tasks)}[/bold] parallel tasks.")
+            
+            # Queue them
+            dispatcher.enqueue_batch(tasks)
+            for t in tasks:
+                state_mgr.add_task(t["id"], "queued", t["meta"])
+                
+            console.print("[dim]Tasks have been dispatched to the worker queue.[/dim]")
+            console.print(f"👉 [bold magenta]Watch live progress at: http://localhost:5050[/bold magenta]")
+            
+            # Simple live status wait
+            with Progress() as pb:
+                task_pb = pb.add_task("Executing Pipeline...", total=len(tasks))
+                while True:
+                    q = dispatcher.get_queue()
+                    completed = q["done"] + q["failed"]
+                    pb.update(task_pb, completed=completed)
+                    
+                    if completed >= len(tasks):
+                        break
+                    time.sleep(1)
+                    
+            console.print("\n[bold green]✅ All tasks completed successfully![/bold green]")
+            
+    except KeyboardInterrupt:
+        console.print("\n[dim]Shutting down...[/dim]")
+        
+    finally:
+        if DASHBOARD_PROCESS:
+            DASHBOARD_PROCESS.terminate()
+
+if __name__ == "__main__":
+    show_welcome()
+    main_loop()