claude-flow-novice 2.2.4 → 2.2.5

package/scripts/validate-template-bundling.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+/**
+ * Validate Template Bundling
+ *
+ * Verifies that:
+ * 1. All template directories exist
+ * 2. Required files are present in each template
+ * 3. Templates can be read and parsed
+ * 4. Package.json includes templates/ directory
+ */
+
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const projectRoot = join(__dirname, '..');
+
+const REQUIRED_TEMPLATES = [
+  'basic-swarm',
+  'fleet-manager',
+  'event-bus',
+  'custom-agent'
+];
+
+const REQUIRED_FILES = {
+  'basic-swarm': ['CLAUDE.md', 'package.json', '.claude/settings.json', 'coordination.md', 'memory-bank.md'],
+  'fleet-manager': ['CLAUDE.md', 'package.json', '.claude/settings.json'],
+  'event-bus': ['CLAUDE.md', 'package.json', '.claude/settings.json'],
+  'custom-agent': ['CLAUDE.md', 'package.json', '.claude/settings.json']
+};
+
+async function validateTemplates() {
+  const results = {
+    success: true,
+    templatesChecked: 0,
+    filesChecked: 0,
+    errors: [],
+    warnings: []
+  };
+
+  console.log('🔍 Validating Template Bundling...\n');
+
+  // Check templates directory exists
+  const templatesDir = join(projectRoot, 'templates');
+  try {
+    await fs.access(templatesDir);
+    console.log('✅ Templates directory exists:', templatesDir);
+  } catch (err) {
+    results.success = false;
+    results.errors.push('Templates directory not found');
+    console.log('❌ Templates directory not found:', templatesDir);
+    return results;
+  }
+
+  // Check each required template
+  for (const template of REQUIRED_TEMPLATES) {
+    const templateDir = join(templatesDir, template);
+
+    try {
+      await fs.access(templateDir);
+      console.log(`\n✅ Template directory exists: ${template}/`);
+      results.templatesChecked++;
+
+      // Check required files
+      const requiredFiles = REQUIRED_FILES[template] || [];
+      for (const file of requiredFiles) {
+        const filePath = join(templateDir, file);
+
+        try {
+          const stats = await fs.stat(filePath);
+
+          if (stats.size === 0) {
+            results.warnings.push(`${template}/${file} is empty`);
+            console.log(`  ⚠️  ${file} (EMPTY)`);
+          } else {
+            console.log(`  ✅ ${file} (${stats.size} bytes)`);
+          }
+
+          results.filesChecked++;
+
+          // Validate JSON files can be parsed
+          if (file.endsWith('.json')) {
+            try {
+              const content = await fs.readFile(filePath, 'utf8');
+              JSON.parse(content);
+              console.log(`     ✓ Valid JSON`);
+            } catch (err) {
+              results.errors.push(`${template}/${file} contains invalid JSON`);
+              console.log(`     ❌ Invalid JSON: ${err.message}`);
+              results.success = false;
+            }
+          }
+
+          // Validate Markdown files are not empty
+          if (file.endsWith('.md')) {
+            try {
+              const content = await fs.readFile(filePath, 'utf8');
+              if (content.trim().length < 10) {
+                results.warnings.push(`${template}/${file} appears to be empty or too short`);
+                console.log(`     ⚠️  Content too short (${content.length} chars)`);
+              } else {
+                console.log(`     ✓ ${content.length} characters`);
+              }
+            } catch (err) {
+              results.errors.push(`Failed to read ${template}/${file}`);
+              console.log(`     ❌ Failed to read: ${err.message}`);
+            }
+          }
+        } catch (err) {
+          results.errors.push(`${template}/${file} not found`);
+          console.log(`  ❌ ${file} not found`);
+          results.success = false;
+        }
+      }
+    } catch (err) {
+      results.success = false;
+      results.errors.push(`Template directory ${template} not found`);
+      console.log(`❌ Template directory not found: ${template}/`);
+    }
+  }
+
+  // Check package.json includes templates
+  console.log('\n🔍 Checking package.json...');
+  try {
+    const packagePath = join(projectRoot, 'package.json');
+    const packageContent = await fs.readFile(packagePath, 'utf8');
+    const packageJson = JSON.parse(packageContent);
+
+    if (packageJson.files && packageJson.files.includes('templates/')) {
+      console.log('✅ package.json includes "templates/" in files array');
+    } else {
+      results.success = false;
+      results.errors.push('package.json does not include "templates/" in files array');
+      console.log('❌ package.json does not include "templates/" in files array');
+    }
+  } catch (err) {
+    results.warnings.push(`Failed to validate package.json: ${err.message}`);
+    console.log(`⚠️  Failed to validate package.json: ${err.message}`);
+  }
+
+  // Summary
+  console.log('\n' + '='.repeat(60));
+  console.log('📊 VALIDATION SUMMARY');
+  console.log('='.repeat(60));
+  console.log(`Templates checked: ${results.templatesChecked}/${REQUIRED_TEMPLATES.length}`);
+  console.log(`Files validated: ${results.filesChecked}`);
+  console.log(`Errors: ${results.errors.length}`);
+  console.log(`Warnings: ${results.warnings.length}`);
+
+  if (results.errors.length > 0) {
+    console.log('\n❌ ERRORS:');
+    results.errors.forEach(err => console.log(`  • ${err}`));
+  }
+
+  if (results.warnings.length > 0) {
+    console.log('\n⚠️  WARNINGS:');
+    results.warnings.forEach(warn => console.log(`  • ${warn}`));
+  }
+
+  console.log('\n' + '='.repeat(60));
+  if (results.success) {
+    console.log('✅ VALIDATION PASSED');
+    console.log('\nTemplates are ready for bundling with npm package!');
+  } else {
+    console.log('❌ VALIDATION FAILED');
+    console.log('\nFix errors before publishing.');
+    process.exit(1);
+  }
+
+  return results;
+}
+
+// Run validation
+validateTemplates().catch(err => {
+  console.error('❌ Validation failed:', err);
+  process.exit(1);
+});

package/scripts/validation/README.md

@@ -0,0 +1,33 @@
+# Validation Scripts
+
+## Purpose
+
+This directory contains validation and consensus scripts for the Claude Flow Novice project. Scripts have been moved from the project root to improve organization and maintainability.
+
+## Script Types
+
+### Security Validation
+- Security audit and vulnerability scanning scripts
+- Code security analysis tools
+- Dependency security validation
+
+### Phase Validation
+- CFN Loop phase validation scripts
+- Sprint completion validation
+- Epic milestone verification
+
+### Consensus Reports
+- Consensus score calculation and reporting
+- Validator team coordination scripts
+- Confidence metric aggregation
+
+## Usage
+
+All validation scripts should be executed from the project root directory to ensure proper path resolution and access to project resources.
+
+## Organization
+
+Scripts in this directory follow the project's organizational standards:
+- No working files stored in root
+- Validation logic separated by concern
+- Clear naming conventions for script purpose

package/scripts/validation/acl-security-validation.cjs

@@ -0,0 +1,214 @@
+/**
+ * ACL Security Validation Script
+ * Phase 1 Foundation Infrastructure Security Validation
+ *
+ * Validates the 6-level ACL system with project-level isolation
+ */
+
+const SwarmMemoryManager = require('./src/sqlite/SwarmMemoryManager.cjs');
+const fs = require('fs');
+const path = require('path');
+
+class ACLSecurityValidator {
+  constructor() {
+    this.testResults = [];
+    this.memoryManager = null;
+    this.testDbPath = path.join(__dirname, 'test-acl-validation.db');
+  }
+
+  async setup() {
+    // Clean up any existing test database
+    if (fs.existsSync(this.testDbPath)) {
+      fs.unlinkSync(this.testDbPath);
+    }
+
+    // Initialize memory manager with test database
+    this.memoryManager = new SwarmMemoryManager({
+      dbPath: this.testDbPath,
+      encryptionKey: Buffer.from('test-encryption-key-32-bytes-long', 'utf8'),
+      aclCacheTimeout: 1000 // Short cache for testing
+    });
+
+    await this.memoryManager.initialize();
+  }
+
+  async cleanup() {
+    if (this.memoryManager) {
+      await this.memoryManager.close();
+    }
+    if (fs.existsSync(this.testDbPath)) {
+      fs.unlinkSync(this.testDbPath);
+    }
+  }
+
+  logResult(testName, passed, details = '') {
+    const result = {
+      test: testName,
+      passed,
+      details,
+      timestamp: new Date().toISOString()
+    };
+    this.testResults.push(result);
+
+    const status = passed ? '✅ PASS' : '❌ FAIL';
+    console.log(`${status}: ${testName}`);
+    if (details) {
+      console.log(`   ${details}`);
+    }
+  }
+
+  async testProjectLevelACL() {
+    const projectId1 = 'project-alpha';
+    const projectId2 = 'project-beta';
+    const agent1 = 'agent-project-1';
+    const agent2 = 'agent-project-2';
+    const agent3 = 'agent-project-3';
+
+    const projectData1 = { confidential: 'project-alpha-secret' };
+    const projectData2 = { confidential: 'project-beta-secret' };
+
+    try {
+      // Store project-specific data
+      await this.memoryManager.set('project-key-1', projectData1, {
+        agentId: agent1,
+        projectId: projectId1,
+        aclLevel: 4, // Project level
+        namespace: 'test'
+      });
+
+      await this.memoryManager.set('project-key-2', projectData2, {
+        agentId: agent2,
+        projectId: projectId2,
+        aclLevel: 4, // Project level
+        namespace: 'test'
+      });
+
+      // Same project agent should access data from their project
+      const sameProjectAccess = await this.memoryManager.get('project-key-1', {
+        agentId: agent3,
+        projectId: projectId1,
+        namespace: 'test'
+      });
+
+      // Different project agent should be DENIED access - SECURITY CRITICAL
+      const crossProjectAccess = await this.memoryManager.get('project-key-1', {
+        agentId: agent2,
+        projectId: projectId2,
+        namespace: 'test'
+      });
+
+      const passed = JSON.stringify(sameProjectAccess) === JSON.stringify(projectData1) &&
+                     crossProjectAccess === null;
+
+      this.logResult('Project Level (4) ACL - CRITICAL SECURITY', passed,
+        passed ? 'Project isolation working correctly' : 'CROSS-PROJECT DATA LEAK DETECTED');
+    } catch (error) {
+      this.logResult('Project Level (4) ACL - CRITICAL SECURITY', false, `Error: ${error.message}`);
+    }
+  }
+
+  async testBasicACL() {
+    const agent1 = 'agent-basic-1';
+    const agent2 = 'agent-basic-2';
+    const data = { test: 'basic-data' };
+
+    try {
+      // Store private data
+      await this.memoryManager.set('basic-key', data, {
+        agentId: agent1,
+        aclLevel: 1,
+        namespace: 'test'
+      });
+
+      // Owner should access
+      const ownerAccess = await this.memoryManager.get('basic-key', {
+        agentId: agent1,
+        namespace: 'test'
+      });
+
+      // Other agent should be denied
+      const otherAccess = await this.memoryManager.get('basic-key', {
+        agentId: agent2,
+        namespace: 'test'
+      });
+
+      const passed = JSON.stringify(ownerAccess) === JSON.stringify(data) &&
+                     otherAccess === null;
+
+      this.logResult('Basic Private ACL', passed,
+        passed ? 'Private access working' : 'Private access failure');
+    } catch (error) {
+      this.logResult('Basic Private ACL', false, `Error: ${error.message}`);
+    }
+  }
+
+  async generateSecurityReport() {
+    const totalTests = this.testResults.length;
+    const passedTests = this.testResults.filter(r => r.passed).length;
+    const failedTests = totalTests - passedTests;
+    const passRate = ((passedTests / totalTests) * 100).toFixed(1);
+
+    const report = {
+      summary: {
+        totalTests,
+        passedTests,
+        failedTests,
+        passRate: `${passRate}%`,
+        timestamp: new Date().toISOString()
+      },
+      criticalFindings: this.testResults.filter(r =>
+        !r.passed && r.test.includes('CRITICAL')
+      ),
+      details: this.testResults
+    };
+
+    // Write security report
+    const reportPath = path.join(__dirname, 'acl-security-report.json');
+    fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+
+    console.log('\n' + '='.repeat(60));
+    console.log('🔒 ACL SECURITY VALIDATION REPORT');
+    console.log('='.repeat(60));
+    console.log(`Total Tests: ${totalTests}`);
+    console.log(`Passed: ${passedTests} ✅`);
+    console.log(`Failed: ${failedTests} ❌`);
+    console.log(`Pass Rate: ${passRate}%`);
+
+    if (report.criticalFindings.length > 0) {
+      console.log('\n🚨 CRITICAL SECURITY ISSUES:');
+      report.criticalFindings.forEach(finding => {
+        console.log(`   ❌ ${finding.test}: ${finding.details}`);
+      });
+    }
+
+    console.log(`\n📄 Full report saved to: ${reportPath}`);
+    console.log('='.repeat(60));
+
+    return report;
+  }
+
+  async runAllTests() {
+    console.log('🔒 Starting ACL Security Validation...');
+    console.log('Testing 6-level ACL system with project isolation\n');
+
+    await this.setup();
+
+    // Run security tests
+    await this.testBasicACL();
+    await this.testProjectLevelACL();
+
+    const report = await this.generateSecurityReport();
+
+    await this.cleanup();
+
+    return report;
+  }
+}
+
+// Run validation if called directly
+if (require.main === module) {
+  const validator = new ACLSecurityValidator();
+  validator.runAllTests().catch(console.error);
+}
+
+module.exports = ACLSecurityValidator;