claude-flow-novice 1.2.0 → 1.3.0

package/examples/05-swarm-apps/rest-api-advanced/tests/unit/auth.service.test.js

@@ -0,0 +1,403 @@
+import { describe, test, it, expect, beforeEach } from '@jest/globals';
+const jwt = require('jsonwebtoken');
+const crypto = require('crypto');
+const authService = require('../../src/services/auth.service');
+const User = require('../../src/models/User');
+const Token = require('../../src/models/token.model');
+const ApiError = require('../../src/utils/ApiError');
+const { getRedisClient } = require('../../src/config/redis');
+
+// Mock dependencies
+jest.mock('jsonwebtoken');
+jest.mock('../../src/models/User');
+jest.mock('../../src/models/token.model');
+jest.mock('../../src/config/redis');
+jest.mock('../../src/utils/logger', () => ({
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+}));
+
+describe('AuthService', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Set default environment variables
+    process.env.JWT_SECRET = 'test-secret';
+    process.env.JWT_EXPIRE = '7d';
+    process.env.API_URL = 'http://localhost:3000';
+  });
+
+  describe('generateAccessToken', () => {
+    it('should generate a valid JWT token', () => {
+      const user = {
+        _id: '123456',
+        email: 'test@example.com',
+        role: 'user',
+      };
+      const mockToken = 'mock.jwt.token';
+      
+      jwt.sign.mockReturnValue(mockToken);
+
+      const token = authService.generateAccessToken(user);
+
+      expect(jwt.sign).toHaveBeenCalledWith(
+        {
+          id: user._id,
+          email: user.email,
+          role: user.role,
+        },
+        process.env.JWT_SECRET,
+        {
+          expiresIn: process.env.JWT_EXPIRE,
+        }
+      );
+      expect(token).toBe(mockToken);
+    });
+
+    it('should use default expiry if JWT_EXPIRE is not set', () => {
+      delete process.env.JWT_EXPIRE;
+      const user = {
+        _id: '123456',
+        email: 'test@example.com',
+        role: 'user',
+      };
+
+      authService.generateAccessToken(user);
+
+      expect(jwt.sign).toHaveBeenCalledWith(
+        expect.any(Object),
+        expect.any(String),
+        {
+          expiresIn: '7d',
+        }
+      );
+    });
+  });
+
+  describe('generateRefreshToken', () => {
+    it('should create and return a refresh token', async () => {
+      const userId = '123456';
+      const deviceInfo = { device: 'mobile', browser: 'Chrome' };
+      const mockTokenDoc = { token: 'refresh-token-123' };
+
+      Token.createRefreshToken.mockResolvedValue(mockTokenDoc);
+
+      const token = await authService.generateRefreshToken(userId, deviceInfo);
+
+      expect(Token.createRefreshToken).toHaveBeenCalledWith(userId, deviceInfo);
+      expect(token).toBe('refresh-token-123');
+    });
+
+    it('should work without device info', async () => {
+      const userId = '123456';
+      const mockTokenDoc = { token: 'refresh-token-123' };
+
+      Token.createRefreshToken.mockResolvedValue(mockTokenDoc);
+
+      const token = await authService.generateRefreshToken(userId);
+
+      expect(Token.createRefreshToken).toHaveBeenCalledWith(userId, {});
+      expect(token).toBe('refresh-token-123');
+    });
+  });
+
+  describe('refreshAccessToken', () => {
+    it('should refresh access token with valid refresh token', async () => {
+      const refreshToken = 'valid-refresh-token';
+      const mockUser = {
+        _id: '123456',
+        email: 'test@example.com',
+        role: 'user',
+        isActive: true,
+      };
+      const mockTokenDoc = {
+        token: refreshToken,
+        user: mockUser,
+        deviceInfo: { device: 'mobile' },
+        save: jest.fn(),
+      };
+
+      Token.findOne.mockReturnValue({
+        populate: jest.fn().mockResolvedValue(mockTokenDoc),
+      });
+      jwt.sign.mockReturnValue('new-access-token');
+
+      const result = await authService.refreshAccessToken(refreshToken);
+
+      expect(Token.findOne).toHaveBeenCalledWith({
+        token: refreshToken,
+        type: 'refresh',
+        used: false,
+        expiresAt: { $gt: expect.any(Date) },
+      });
+      expect(result.accessToken).toBe('new-access-token');
+      expect(result.refreshToken).toBe(refreshToken);
+      expect(result.user).toBe(mockUser);
+    });
+
+    it('should rotate refresh token when enabled', async () => {
+      process.env.ROTATE_REFRESH_TOKENS = 'true';
+      const refreshToken = 'old-refresh-token';
+      const mockUser = {
+        _id: '123456',
+        email: 'test@example.com',
+        role: 'user',
+        isActive: true,
+      };
+      const mockTokenDoc = {
+        token: refreshToken,
+        user: mockUser,
+        deviceInfo: { device: 'mobile' },
+        save: jest.fn(),
+      };
+
+      Token.findOne.mockReturnValue({
+        populate: jest.fn().mockResolvedValue(mockTokenDoc),
+      });
+      Token.createRefreshToken.mockResolvedValue({ token: 'new-refresh-token' });
+      jwt.sign.mockReturnValue('new-access-token');
+
+      const result = await authService.refreshAccessToken(refreshToken);
+
+      expect(mockTokenDoc.used).toBe(true);
+      expect(mockTokenDoc.usedAt).toBeInstanceOf(Date);
+      expect(mockTokenDoc.save).toHaveBeenCalled();
+      expect(result.refreshToken).toBe('new-refresh-token');
+    });
+
+    it('should throw error for invalid refresh token', async () => {
+      const refreshToken = 'invalid-refresh-token';
+
+      Token.findOne.mockReturnValue({
+        populate: jest.fn().mockResolvedValue(null),
+      });
+
+      await expect(authService.refreshAccessToken(refreshToken))
+        .rejects
+        .toThrow(new ApiError('Invalid or expired refresh token', 401));
+    });
+
+    it('should throw error for inactive user', async () => {
+      const refreshToken = 'valid-refresh-token';
+      const mockUser = {
+        _id: '123456',
+        email: 'test@example.com',
+        role: 'user',
+        isActive: false,
+      };
+      const mockTokenDoc = {
+        token: refreshToken,
+        user: mockUser,
+      };
+
+      Token.findOne.mockReturnValue({
+        populate: jest.fn().mockResolvedValue(mockTokenDoc),
+      });
+
+      await expect(authService.refreshAccessToken(refreshToken))
+        .rejects
+        .toThrow(new ApiError('Account has been deactivated', 401));
+    });
+  });
+
+  describe('blacklistToken', () => {
+    it('should blacklist token in Redis', async () => {
+      const token = 'jwt-token';
+      const mockRedis = {
+        setex: jest.fn().mockResolvedValue('OK'),
+      };
+      getRedisClient.mockReturnValue(mockRedis);
+      jwt.decode.mockReturnValue({ exp: Math.floor(Date.now() / 1000) + 3600 });
+
+      await authService.blacklistToken(token);
+
+      expect(mockRedis.setex).toHaveBeenCalledWith(
+        `blacklist_${token}`,
+        expect.any(Number),
+        '1'
+      );
+    });
+
+    it('should use provided TTL', async () => {
+      const token = 'jwt-token';
+      const ttl = 1800; // 30 minutes
+      const mockRedis = {
+        setex: jest.fn().mockResolvedValue('OK'),
+      };
+      getRedisClient.mockReturnValue(mockRedis);
+
+      await authService.blacklistToken(token, ttl);
+
+      expect(mockRedis.setex).toHaveBeenCalledWith(
+        `blacklist_${token}`,
+        ttl,
+        '1'
+      );
+    });
+
+    it('should handle Redis not available', async () => {
+      const token = 'jwt-token';
+      getRedisClient.mockReturnValue(null);
+
+      await expect(authService.blacklistToken(token)).resolves.not.toThrow();
+    });
+
+    it('should handle Redis errors gracefully', async () => {
+      const token = 'jwt-token';
+      const mockRedis = {
+        setex: jest.fn().mockRejectedValue(new Error('Redis error')),
+      };
+      getRedisClient.mockReturnValue(mockRedis);
+
+      await expect(authService.blacklistToken(token)).resolves.not.toThrow();
+    });
+  });
+
+  describe('validatePasswordStrength', () => {
+    it('should validate strong password', () => {
+      const password = 'MyStr0ng!Pass';
+      const result = authService.validatePasswordStrength(password);
+
+      expect(result.isValid).toBe(true);
+      expect(result.score).toBe(5);
+      expect(result.level).toBe('strong');
+      expect(result.feedback).toHaveLength(0);
+    });
+
+    it('should validate weak password', () => {
+      const password = 'weak';
+      const result = authService.validatePasswordStrength(password);
+
+      expect(result.isValid).toBe(false);
+      expect(result.level).toBe('weak');
+      expect(result.feedback).toContain('Password must be at least 8 characters long');
+      expect(result.feedback).toContain('Password should contain at least one uppercase letter');
+      expect(result.feedback).toContain('Password should contain at least one number');
+      expect(result.feedback).toContain('Password should contain at least one special character');
+    });
+
+    it('should validate medium strength password', () => {
+      const password = 'password123';
+      const result = authService.validatePasswordStrength(password);
+
+      expect(result.isValid).toBe(true);
+      expect(result.level).toBe('medium');
+      expect(result.feedback).toContain('Password should contain at least one uppercase letter');
+      expect(result.feedback).toContain('Password should contain at least one special character');
+    });
+  });
+
+  describe('extractDeviceInfo', () => {
+    it('should extract mobile device info', () => {
+      const req = {
+        headers: {
+          'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) Mobile/15E148 Safari/604.1',
+        },
+        ip: '192.168.1.1',
+      };
+
+      const deviceInfo = authService.extractDeviceInfo(req);
+
+      expect(deviceInfo.device).toBe('mobile');
+      expect(deviceInfo.browser).toBe('Safari');
+      expect(deviceInfo.os).toBe('iOS');
+      expect(deviceInfo.ip).toBe('192.168.1.1');
+    });
+
+    it('should extract desktop device info', () => {
+      const req = {
+        headers: {
+          'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+        },
+        ip: '192.168.1.2',
+      };
+
+      const deviceInfo = authService.extractDeviceInfo(req);
+
+      expect(deviceInfo.device).toBe('desktop');
+      expect(deviceInfo.browser).toBe('Chrome');
+      expect(deviceInfo.os).toBe('Windows');
+    });
+
+    it('should handle missing user agent', () => {
+      const req = {
+        headers: {},
+        ip: '192.168.1.1',
+      };
+
+      const deviceInfo = authService.extractDeviceInfo(req);
+
+      expect(deviceInfo.device).toBe('unknown');
+      expect(deviceInfo.browser).toBe('unknown');
+      expect(deviceInfo.os).toBe('unknown');
+    });
+  });
+
+  describe('generateSecureToken', () => {
+    it('should generate a secure token with default length', () => {
+      const mockBuffer = Buffer.from('1234567890abcdef1234567890abcdef', 'hex');
+      jest.spyOn(crypto, 'randomBytes').mockReturnValue(mockBuffer);
+
+      const token = authService.generateSecureToken();
+
+      expect(crypto.randomBytes).toHaveBeenCalledWith(32);
+      expect(token).toBe(mockBuffer.toString('hex'));
+    });
+
+    it('should generate a secure token with custom length', () => {
+      const mockBuffer = Buffer.from('1234567890abcdef', 'hex');
+      jest.spyOn(crypto, 'randomBytes').mockReturnValue(mockBuffer);
+
+      const token = authService.generateSecureToken(16);
+
+      expect(crypto.randomBytes).toHaveBeenCalledWith(16);
+      expect(token).toBe(mockBuffer.toString('hex'));
+    });
+  });
+
+  describe('hashToken', () => {
+    it('should hash a token using SHA256', () => {
+      const token = 'my-secret-token';
+      const expectedHash = crypto.createHash('sha256').update(token).digest('hex');
+
+      const hash = authService.hashToken(token);
+
+      expect(hash).toBe(expectedHash);
+      expect(hash).toHaveLength(64); // SHA256 produces 64 hex characters
+    });
+  });
+
+  describe('sendVerificationEmail', () => {
+    it('should prepare verification email', async () => {
+      const user = {
+        email: 'test@example.com',
+        name: 'Test User',
+      };
+      const token = 'verification-token';
+
+      const emailData = await authService.sendVerificationEmail(user, token);
+
+      expect(emailData.to).toBe(user.email);
+      expect(emailData.subject).toBe('Verify Your Email');
+      expect(emailData.body).toContain(user.name);
+      expect(emailData.body).toContain(`${process.env.API_URL}/api/auth/verify-email/${token}`);
+    });
+  });
+
+  describe('sendPasswordResetEmail', () => {
+    it('should prepare password reset email', async () => {
+      const user = {
+        email: 'test@example.com',
+        name: 'Test User',
+      };
+      const token = 'reset-token';
+
+      const emailData = await authService.sendPasswordResetEmail(user, token);
+
+      expect(emailData.to).toBe(user.email);
+      expect(emailData.subject).toBe('Password Reset Request');
+      expect(emailData.body).toContain(user.name);
+      expect(emailData.body).toContain(`${process.env.API_URL}/reset-password?token=${token}`);
+    });
+  });
+});

package/examples/05-swarm-apps/swarm-created-app/README.md

@@ -0,0 +1,93 @@
+# Task Manager CLI
+
+A command-line task management application created by the Claude Flow Swarm system.
+
+## Swarm Creation Process
+
+This application was created through coordinated effort of multiple swarm agents:
+
+### Agent Contributions
+
+1. **Coordinator-1**: Decomposed the objective into subtasks
+2. **Developer-1**: Implemented the core TaskManager class
+3. **Developer-2**: Created the CLI interface
+4. **Tester-1**: Developed comprehensive test suite
+5. **Documenter-1**: Generated this documentation
+
+### Task Execution Timeline
+
+```
+[00:00] Objective received: "create task manager with CRUD operations"
+[00:01] Task decomposition completed (5 subtasks identified)
+[00:02] Agents assigned to tasks
+[00:05] Core implementation completed
+[00:07] CLI interface completed
+[00:09] Test suite completed
+[00:10] Documentation completed
+[00:11] Quality review passed
+```
+
+## Features
+
+- Add tasks with priority levels
+- List all tasks with status indicators
+- Mark tasks as completed
+- View task statistics
+- Swarm agent attribution for each operation
+
+## Installation
+
+```bash
+# No installation needed - it's a standalone Node.js application
+node task-manager.js --help
+```
+
+## Usage Examples
+
+```bash
+# Add a new task
+node task-manager.js add "Review pull request"
+
+# List all tasks
+node task-manager.js list
+
+# Complete a task
+node task-manager.js complete 1
+
+# View statistics
+node task-manager.js stats
+```
+
+## Architecture
+
+The application follows a modular architecture designed by the swarm:
+
+```
+TaskManager (Core Class)
+    ├── Task Management
+    │   ├── addTask()
+    │   ├── listTasks()
+    │   └── completeTask()
+    └── Analytics
+        └── getStats()
+```
+
+## Testing
+
+Run the test suite created by Tester-1:
+
+```bash
+node task-manager.test.js
+```
+
+## Swarm Benefits Demonstrated
+
+1. **Parallel Development**: Multiple agents worked simultaneously
+2. **Specialization**: Each agent focused on their expertise
+3. **Quality Assurance**: Built-in testing and documentation
+4. **Rapid Development**: Complete application in minutes
+5. **Best Practices**: Follows coding standards and patterns
+
+---
+
+Created by Claude Flow Swarm v1.0.49

package/examples/05-swarm-apps/swarm-created-app/task-manager.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+/**
+ * Task Manager CLI Application
+ * Created by Claude Flow Swarm
+ * 
+ * Demonstrates:
+ * - Multi-agent collaboration
+ * - Task decomposition and execution
+ * - Quality assurance through testing
+ * - Comprehensive documentation
+ */
+
+class TaskManager {
+    constructor() {
+        this.tasks = [];
+        this.nextId = 1;
+    }
+
+    addTask(description, priority = 'medium') {
+        const task = {
+            id: this.nextId++,
+            description,
+            priority,
+            status: 'pending',
+            createdAt: new Date(),
+            swarmAgent: 'Developer-1'
+        };
+        this.tasks.push(task);
+        return task;
+    }
+
+    listTasks() {
+        return this.tasks;
+    }
+
+    completeTask(id) {
+        const task = this.tasks.find(t => t.id === id);
+        if (task) {
+            task.status = 'completed';
+            task.completedAt = new Date();
+            task.swarmAgent = 'Executor-1';
+        }
+        return task;
+    }
+
+    getStats() {
+        const total = this.tasks.length;
+        const completed = this.tasks.filter(t => t.status === 'completed').length;
+        const pending = total - completed;
+        
+        return {
+            total,
+            completed,
+            pending,
+            completionRate: total > 0 ? (completed / total * 100).toFixed(1) + '%' : '0%'
+        };
+    }
+}
+
+// CLI Interface
+if (require.main === module) {
+    const manager = new TaskManager();
+    const args = process.argv.slice(2);
+    const command = args[0];
+    
+    console.log('📋 Task Manager - Created by Swarm');
+    console.log('==================================\n');
+    
+    switch (command) {
+        case 'add':
+            const task = manager.addTask(args.slice(1).join(' '));
+            console.log(`✅ Task added: #${task.id} - ${task.description}`);
+            break;
+            
+        case 'list':
+            const tasks = manager.listTasks();
+            if (tasks.length === 0) {
+                console.log('No tasks found.');
+            } else {
+                tasks.forEach(t => {
+                    const status = t.status === 'completed' ? '✓' : '○';
+                    console.log(`${status} #${t.id} [${t.priority}] ${t.description}`);
+                });
+            }
+            break;
+            
+        case 'complete':
+            const completed = manager.completeTask(parseInt(args[1]));
+            if (completed) {
+                console.log(`✅ Task #${completed.id} marked as completed`);
+            }
+            break;
+            
+        case 'stats':
+            const stats = manager.getStats();
+            console.log('📊 Task Statistics:');
+            console.log(`   Total: ${stats.total}`);
+            console.log(`   Completed: ${stats.completed}`);
+            console.log(`   Pending: ${stats.pending}`);
+            console.log(`   Completion Rate: ${stats.completionRate}`);
+            break;
+            
+        default:
+            console.log('Usage:');
+            console.log('  node task-manager.js add <description>');
+            console.log('  node task-manager.js list');
+            console.log('  node task-manager.js complete <id>');
+            console.log('  node task-manager.js stats');
+    }
+    
+    console.log('\n🐝 Created by Claude Flow Swarm agents working in parallel');
+}
+
+module.exports = TaskManager;

package/examples/05-swarm-apps/swarm-created-app/task-manager.test.js

@@ -0,0 +1,36 @@
+/**
+ * Test Suite for Task Manager
+ * Created by Swarm Agent: Tester-1
+ */
+
+const TaskManager = require('./task-manager.js');
+const assert = require('assert');
+
+console.log('🧪 Running Task Manager Tests...\n');
+
+// Test 1: Add tasks
+const manager = new TaskManager();
+const task1 = manager.addTask('Write documentation', 'high');
+assert(task1.id === 1, 'First task should have ID 1');
+assert(task1.priority === 'high', 'Priority should be set correctly');
+console.log('✅ Test 1 passed: Add tasks');
+
+// Test 2: List tasks
+const tasks = manager.listTasks();
+assert(tasks.length === 1, 'Should have one task');
+console.log('✅ Test 2 passed: List tasks');
+
+// Test 3: Complete tasks
+const completed = manager.completeTask(1);
+assert(completed.status === 'completed', 'Task should be completed');
+console.log('✅ Test 3 passed: Complete tasks');
+
+// Test 4: Statistics
+const stats = manager.getStats();
+assert(stats.total === 1, 'Total should be 1');
+assert(stats.completed === 1, 'Completed should be 1');
+assert(stats.completionRate === '100.0%', 'Completion rate should be 100%');
+console.log('✅ Test 4 passed: Statistics');
+
+console.log('\n🎉 All tests passed!');
+console.log('Quality assured by swarm testing agents.');

package/examples/05-swarm-apps/swarm-sample/.notes-cli/notes.json

@@ -0,0 +1,20 @@
+[
+  {
+    "id": "1749848000001",
+    "title": "Welcome to Notes CLI",
+    "content": "This is your first note created by the Claude Flow Swarm system!",
+    "tags": ["welcome", "swarm"],
+    "createdAt": "2025-06-13T20:00:00.000Z",
+    "updatedAt": "2025-06-13T20:00:00.000Z",
+    "swarmAgent": "Coordinator-1"
+  },
+  {
+    "id": "1749848000002",
+    "title": "Swarm Development Process",
+    "content": "This app was created by 6 specialized agents working in parallel: Coordinator, 2 Developers, Tester, Reviewer, and Documenter.",
+    "tags": ["swarm", "development"],
+    "createdAt": "2025-06-13T20:01:00.000Z",
+    "updatedAt": "2025-06-13T20:01:00.000Z",
+    "swarmAgent": "Documenter-1"
+  }
+]