@litmers/cursorflow-orchestrator 0.1.0 → 0.1.2

package/scripts/setup-security.sh

@@ -0,0 +1,105 @@
+#!/bin/bash
+
+# 보안 검사 설정 스크립트
+# GitHub Secrets 설정을 위한 가이드
+
+set -e
+
+# 색상 정의
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+echo -e "${BLUE}╔════════════════════════════════════════╗${NC}"
+echo -e "${BLUE}║   🔒 Security Scan Setup Guide       ║${NC}"
+echo -e "${BLUE}╚════════════════════════════════════════╝${NC}\n"
+
+# GitHub CLI 확인
+if ! command -v gh &> /dev/null; then
+    echo -e "${YELLOW}⚠️  GitHub CLI (gh) is not installed.${NC}"
+    echo -e "Install it from: https://cli.github.com/\n"
+    USE_GH_CLI=false
+else
+    echo -e "${GREEN}✓ GitHub CLI detected${NC}\n"
+    USE_GH_CLI=true
+fi
+
+echo -e "${BLUE}Required GitHub Secrets:${NC}\n"
+
+echo "1. NPM_TOKEN (필수 - npm 배포용)"
+echo "   - Visit: https://www.npmjs.com"
+echo "   - Profile → Access Tokens → Generate New Token"
+echo "   - Type: Automation"
+echo ""
+
+echo "2. SNYK_TOKEN (권장 - 강화된 의존성 스캔)"
+echo "   - Visit: https://snyk.io"
+echo "   - Settings → General → Auth Token"
+echo ""
+
+echo "3. OPENAI_API_KEY (선택 - AI 보안 검사)"
+echo "   - Visit: https://platform.openai.com/api-keys"
+echo "   - Create new secret key"
+echo "   - Cost: ~$0.01-0.10 per PR"
+echo ""
+
+if [ "$USE_GH_CLI" = true ]; then
+    echo -e "\n${BLUE}Would you like to set up secrets now using GitHub CLI?${NC}"
+    read -p "Continue? (y/N): " -n 1 -r
+    echo
+    
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
+        # NPM_TOKEN
+        echo -e "\n${YELLOW}Setting up NPM_TOKEN...${NC}"
+        read -p "Enter your NPM token (or press Enter to skip): " NPM_TOKEN
+        if [ -n "$NPM_TOKEN" ]; then
+            gh secret set NPM_TOKEN -b "$NPM_TOKEN"
+            echo -e "${GREEN}✓ NPM_TOKEN set${NC}"
+        fi
+        
+        # SNYK_TOKEN
+        echo -e "\n${YELLOW}Setting up SNYK_TOKEN (optional)...${NC}"
+        read -p "Enter your Snyk token (or press Enter to skip): " SNYK_TOKEN
+        if [ -n "$SNYK_TOKEN" ]; then
+            gh secret set SNYK_TOKEN -b "$SNYK_TOKEN"
+            echo -e "${GREEN}✓ SNYK_TOKEN set${NC}"
+        fi
+        
+        # OPENAI_API_KEY
+        echo -e "\n${YELLOW}Setting up OPENAI_API_KEY (optional)...${NC}"
+        read -p "Enter your OpenAI API key (or press Enter to skip): " OPENAI_KEY
+        if [ -n "$OPENAI_KEY" ]; then
+            gh secret set OPENAI_API_KEY -b "$OPENAI_KEY"
+            echo -e "${GREEN}✓ OPENAI_API_KEY set${NC}"
+        fi
+        
+        echo -e "\n${GREEN}✅ Secrets configuration complete!${NC}"
+    fi
+else
+    echo -e "${YELLOW}Manual setup required:${NC}"
+    echo "1. Go to: https://github.com/$(git remote get-url origin | sed 's/.*github.com[:/]\(.*\)\.git/\1/')/settings/secrets/actions"
+    echo "2. Click 'New repository secret'"
+    echo "3. Add the secrets listed above"
+fi
+
+echo -e "\n${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${BLUE}Security Checks Enabled:${NC}\n"
+echo "✅ NPM Audit (automatic)"
+echo "✅ TruffleHog Secret Scanning (automatic)"
+echo "✅ Semgrep Static Analysis (automatic)"
+echo "✅ Trivy Filesystem Scan (automatic)"
+echo "✅ CodeQL Analysis (automatic)"
+echo "⚙️  Snyk Scan (requires SNYK_TOKEN)"
+echo "⚙️  AI Security Review (requires OPENAI_API_KEY)"
+
+echo -e "\n${BLUE}Test security scan locally:${NC}"
+echo -e "${GREEN}npm audit${NC}"
+echo -e "${GREEN}npm audit --audit-level=high${NC}"
+
+echo -e "\n${BLUE}For more information:${NC}"
+echo "📖 docs/SECURITY_CHECKS.md"
+
+echo -e "\n${GREEN}Setup complete! 🎉${NC}\n"
+

package/src/cli/init.js

@@ -17,6 +17,7 @@ function parseArgs(args) {
     withCommands: true,
     configOnly: false,
     force: false,
+    gitignore: true,
   };
   
   for (let i = 0; i < args.length; i++) {
@@ -38,6 +39,9 @@ function parseArgs(args) {
       case '--force':
         options.force = true;
         break;
+      case '--no-gitignore':
+        options.gitignore = false;
+        break;
       case '--help':
       case '-h':
         printHelp();
@@ -59,6 +63,7 @@ Options:
   --example           Create example tasks
   --with-commands     Install Cursor commands (default: true)
   --no-commands       Skip Cursor commands installation
+  --no-gitignore      Skip adding _cursorflow to .gitignore
   --config-only       Only create config file
   --force             Overwrite existing files
   --help, -h          Show help
@@ -67,6 +72,7 @@ Examples:
   cursorflow init
   cursorflow init --example
   cursorflow init --config-only
+  cursorflow init --no-gitignore
   `);
 }
 
@@ -155,6 +161,54 @@ cursorflow run ${config.tasksDir}/example/
   logger.success(`Created example README: ${path.relative(projectRoot, readmePath)}`);
 }
 
+/**
+ * Add _cursorflow to .gitignore
+ */
+function updateGitignore(projectRoot) {
+  const gitignorePath = path.join(projectRoot, '.gitignore');
+  const entry = '_cursorflow/';
+  
+  // Check if .gitignore exists
+  if (!fs.existsSync(gitignorePath)) {
+    // Create new .gitignore
+    fs.writeFileSync(gitignorePath, `# CursorFlow\n${entry}\n`, 'utf8');
+    logger.success('Created .gitignore with _cursorflow/');
+    return;
+  }
+  
+  // Read existing .gitignore
+  const content = fs.readFileSync(gitignorePath, 'utf8');
+  
+  // Check if already included
+  const lines = content.split('\n');
+  const hasEntry = lines.some(line => {
+    const trimmed = line.trim();
+    return trimmed === '_cursorflow' || 
+           trimmed === '_cursorflow/' || 
+           trimmed === '/_cursorflow' ||
+           trimmed === '/_cursorflow/';
+  });
+  
+  if (hasEntry) {
+    logger.info('_cursorflow/ already in .gitignore');
+    return;
+  }
+  
+  // Add entry
+  let newContent = content;
+  
+  // Add newline if file doesn't end with one
+  if (!content.endsWith('\n')) {
+    newContent += '\n';
+  }
+  
+  // Add section header and entry
+  newContent += `\n# CursorFlow\n${entry}\n`;
+  
+  fs.writeFileSync(gitignorePath, newContent, 'utf8');
+  logger.success('Added _cursorflow/ to .gitignore');
+}
+
 async function init(args) {
   logger.section('🚀 Initializing CursorFlow');
   
@@ -172,7 +226,7 @@ async function init(args) {
     logger.info('Use --force to overwrite');
   } else {
     try {
-      createDefaultConfig(projectRoot);
+      createDefaultConfig(projectRoot, options.force);
       logger.success(`Created config file: cursorflow.config.js`);
     } catch (error) {
       if (error.message.includes('already exists') && !options.force) {
@@ -197,7 +251,18 @@ async function init(args) {
   logger.info('\n📁 Creating directories...');
   createDirectories(projectRoot, config);
   
-  // 3. Install Cursor commands
+  // 3. Update .gitignore
+  if (options.gitignore) {
+    logger.info('\n📝 Updating .gitignore...');
+    try {
+      updateGitignore(projectRoot);
+    } catch (error) {
+      logger.warn(`Failed to update .gitignore: ${error.message}`);
+      logger.info('You can manually add "_cursorflow/" to your .gitignore');
+    }
+  }
+  
+  // 4. Install Cursor commands
   if (options.withCommands) {
     logger.info('\n📋 Installing Cursor commands...');
     try {
@@ -208,13 +273,13 @@ async function init(args) {
     }
   }
   
-  // 4. Create example tasks
+  // 5. Create example tasks
   if (options.example) {
     logger.info('\n📝 Creating example tasks...');
     createExampleTasks(projectRoot, config);
   }
   
-  // 5. Summary
+  // 6. Summary
   logger.section('✅ CursorFlow initialized successfully!');
   
   console.log('\n📚 Next steps:\n');

package/src/cli/monitor.js

@@ -1,29 +1,216 @@
 #!/usr/bin/env node
 /**
- * CursorFlow monitor command (stub)
+ * CursorFlow monitor command
  */
 
+const fs = require('fs');
+const path = require('path');
 const logger = require('../utils/logger');
+const { loadState } = require('../utils/state');
+const { loadConfig } = require('../utils/config');
 
 function parseArgs(args) {
+  const watch = args.includes('--watch');
+  const intervalIdx = args.indexOf('--interval');
+  const interval = intervalIdx >= 0 ? parseInt(args[intervalIdx + 1]) || 2 : 2;
+  
+  // Find run directory (first non-option argument)
+  const runDir = args.find(arg => !arg.startsWith('--') && args.indexOf(arg) !== intervalIdx + 1);
+  
   return {
-    runDir: args[0],
-    watch: args.includes('--watch'),
-    interval: 2,
+    runDir,
+    watch,
+    interval,
   };
 }
 
+/**
+ * Find the latest run directory
+ */
+function findLatestRunDir(logsDir) {
+  const runsDir = path.join(logsDir, 'runs');
+  
+  if (!fs.existsSync(runsDir)) {
+    return null;
+  }
+  
+  const runs = fs.readdirSync(runsDir)
+    .filter(d => d.startsWith('run-'))
+    .map(d => ({
+      name: d,
+      path: path.join(runsDir, d),
+      mtime: fs.statSync(path.join(runsDir, d)).mtime.getTime(),
+    }))
+    .sort((a, b) => b.mtime - a.mtime);
+  
+  return runs.length > 0 ? runs[0].path : null;
+}
+
+/**
+ * List all lanes in a run directory
+ */
+function listLanes(runDir) {
+  const lanesDir = path.join(runDir, 'lanes');
+  
+  if (!fs.existsSync(lanesDir)) {
+    return [];
+  }
+  
+  return fs.readdirSync(lanesDir)
+    .filter(d => {
+      const stat = fs.statSync(path.join(lanesDir, d));
+      return stat.isDirectory();
+    })
+    .map(name => ({
+      name,
+      path: path.join(lanesDir, name),
+    }));
+}
+
+/**
+ * Get lane status
+ */
+function getLaneStatus(lanePath) {
+  const statePath = path.join(lanePath, 'state.json');
+  const state = loadState(statePath);
+  
+  if (!state) {
+    return {
+      status: 'no state',
+      currentTask: '-',
+      totalTasks: '?',
+      progress: '0%',
+    };
+  }
+  
+  const progress = state.totalTasks > 0 
+    ? Math.round((state.currentTaskIndex / state.totalTasks) * 100)
+    : 0;
+  
+  return {
+    status: state.status || 'unknown',
+    currentTask: state.currentTaskIndex + 1,
+    totalTasks: state.totalTasks || '?',
+    progress: `${progress}%`,
+    pipelineBranch: state.pipelineBranch || '-',
+    chatId: state.chatId || '-',
+  };
+}
+
+/**
+ * Display lane status table
+ */
+function displayStatus(runDir, lanes) {
+  console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log(`📊 Run: ${path.basename(runDir)}`);
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+  
+  if (lanes.length === 0) {
+    console.log('  No lanes found\n');
+    return;
+  }
+  
+  // Calculate column widths
+  const maxNameLen = Math.max(...lanes.map(l => l.name.length), 10);
+  
+  // Header
+  console.log(`  ${'Lane'.padEnd(maxNameLen)}  Status              Progress  Tasks`);
+  console.log(`  ${'─'.repeat(maxNameLen)}  ${'─'.repeat(18)}  ${'─'.repeat(8)}  ${'─'.repeat(10)}`);
+  
+  // Lanes
+  for (const lane of lanes) {
+    const status = getLaneStatus(lane.path);
+    const statusIcon = getStatusIcon(status.status);
+    const statusText = `${statusIcon} ${status.status}`.padEnd(18);
+    const progressText = status.progress.padEnd(8);
+    const tasksText = `${status.currentTask}/${status.totalTasks}`;
+    
+    console.log(`  ${lane.name.padEnd(maxNameLen)}  ${statusText}  ${progressText}  ${tasksText}`);
+  }
+  
+  console.log();
+}
+
+/**
+ * Get status icon
+ */
+function getStatusIcon(status) {
+  const icons = {
+    'running': '🔄',
+    'completed': '✅',
+    'failed': '❌',
+    'blocked_dependency': '🚫',
+    'no state': '⚪',
+  };
+  
+  return icons[status] || '❓';
+}
+
+/**
+ * Monitor lanes
+ */
 async function monitor(args) {
   logger.section('📡 Monitoring Lane Execution');
   
   const options = parseArgs(args);
+  const config = loadConfig();
+  
+  // Determine run directory
+  let runDir = options.runDir;
+  
+  if (!runDir || runDir === 'latest') {
+    runDir = findLatestRunDir(config.logsDir);
+    
+    if (!runDir) {
+      logger.error('No run directories found');
+      logger.info(`Runs directory: ${path.join(config.logsDir, 'runs')}`);
+      process.exit(1);
+    }
+    
+    logger.info(`Using latest run: ${path.basename(runDir)}`);
+  }
   
-  logger.info('This command will be fully implemented in the next phase');
-  logger.info(`Run directory: ${options.runDir || 'latest'}`);
-  logger.info(`Watch mode: ${options.watch}`);
+  if (!fs.existsSync(runDir)) {
+    logger.error(`Run directory not found: ${runDir}`);
+    process.exit(1);
+  }
   
-  logger.warn('\n⚠️  Implementation pending');
-  logger.info('This will show real-time lane status from logs');
+  // Watch mode
+  if (options.watch) {
+    logger.info(`Watch mode: every ${options.interval}s (Ctrl+C to stop)\n`);
+    
+    let iteration = 0;
+    
+    const refresh = () => {
+      if (iteration > 0) {
+        // Clear screen
+        process.stdout.write('\x1Bc');
+      }
+      
+      const lanes = listLanes(runDir);
+      displayStatus(runDir, lanes);
+      
+      iteration++;
+    };
+    
+    // Initial display
+    refresh();
+    
+    // Set up interval
+    const intervalId = setInterval(refresh, options.interval * 1000);
+    
+    // Handle Ctrl+C
+    process.on('SIGINT', () => {
+      clearInterval(intervalId);
+      console.log('\n👋 Monitoring stopped\n');
+      process.exit(0);
+    });
+    
+  } else {
+    // Single shot
+    const lanes = listLanes(runDir);
+    displayStatus(runDir, lanes);
+  }
 }
 
 module.exports = monitor;

package/src/core/runner.js

@@ -15,16 +15,66 @@ const { ensureCursorAgent, checkCursorApiKey } = require('../utils/cursor-agent'
 const { saveState, loadState, appendLog, createConversationEntry, createGitLogEntry } = require('../utils/state');
 
 /**
- * Execute cursor-agent command
+ * Execute cursor-agent command with timeout and better error handling
  */
 function cursorAgentCreateChat() {
   const { execSync } = require('child_process');
-  const out = execSync('cursor-agent create-chat', {
-    encoding: 'utf8',
-    stdio: 'pipe',
-  });
-  const lines = out.split('\n').filter(Boolean);
-  return lines[lines.length - 1] || null;
+  
+  try {
+    const out = execSync('cursor-agent create-chat', {
+      encoding: 'utf8',
+      stdio: 'pipe',
+      timeout: 30000, // 30 second timeout
+    });
+    const lines = out.split('\n').filter(Boolean);
+    const chatId = lines[lines.length - 1] || null;
+    
+    if (!chatId) {
+      throw new Error('Failed to get chat ID from cursor-agent');
+    }
+    
+    logger.info(`Created chat session: ${chatId}`);
+    return chatId;
+  } catch (error) {
+    // Check for common errors
+    if (error.message.includes('ENOENT')) {
+      throw new Error('cursor-agent CLI not found. Install with: npm install -g @cursor/agent');
+    }
+    
+    if (error.message.includes('ETIMEDOUT') || error.killed) {
+      throw new Error('cursor-agent timed out. Check your internet connection and Cursor authentication.');
+    }
+    
+    if (error.stderr) {
+      const stderr = error.stderr.toString();
+      
+      // Check for authentication errors
+      if (stderr.includes('not authenticated') || 
+          stderr.includes('login') || 
+          stderr.includes('auth')) {
+        throw new Error(
+          'Cursor authentication failed. Please:\n' +
+          '  1. Open Cursor IDE\n' +
+          '  2. Sign in to your account\n' +
+          '  3. Verify you can use AI features\n' +
+          '  4. Try running cursorflow again\n\n' +
+          `Original error: ${stderr.trim()}`
+        );
+      }
+      
+      // Check for API key errors
+      if (stderr.includes('api key') || stderr.includes('API_KEY')) {
+        throw new Error(
+          'Cursor API key error. Please check your Cursor account and subscription.\n' +
+          `Error: ${stderr.trim()}`
+        );
+      }
+      
+      throw new Error(`cursor-agent error: ${stderr.trim()}`);
+    }
+    
+    throw new Error(`Failed to create chat: ${error.message}`);
+  }
 }
 
 function parseJsonFromStdout(stdout) {
@@ -57,19 +107,67 @@ function cursorAgentSend({ workspaceDir, chatId, prompt, model }) {
     prompt,
   ];
   
+  logger.info('Executing cursor-agent...');
+  
   const res = spawnSync('cursor-agent', args, {
     encoding: 'utf8',
     stdio: 'pipe',
+    timeout: 300000, // 5 minute timeout for LLM response
   });
   
+  // Check for timeout
+  if (res.error) {
+    if (res.error.code === 'ETIMEDOUT') {
+      return {
+        ok: false,
+        exitCode: -1,
+        error: 'cursor-agent timed out after 5 minutes. The LLM request may be taking too long or there may be network issues.',
+      };
+    }
+    
+    return {
+      ok: false,
+      exitCode: -1,
+      error: `cursor-agent error: ${res.error.message}`,
+    };
+  }
+  
   const json = parseJsonFromStdout(res.stdout);
   
   if (res.status !== 0 || !json || json.type !== 'result') {
-    const msg = res.stderr?.trim() || res.stdout?.trim() || `exit=${res.status}`;
+    let errorMsg = res.stderr?.trim() || res.stdout?.trim() || `exit=${res.status}`;
+    
+    // Check for authentication errors
+    if (errorMsg.includes('not authenticated') || 
+        errorMsg.includes('login') || 
+        errorMsg.includes('auth')) {
+      errorMsg = 'Authentication error. Please:\n' +
+        '  1. Open Cursor IDE\n' +
+        '  2. Sign in to your account\n' +
+        '  3. Verify AI features are working\n' +
+        '  4. Try again\n\n' +
+        `Details: ${errorMsg}`;
+    }
+    
+    // Check for rate limit errors
+    if (errorMsg.includes('rate limit') || errorMsg.includes('quota')) {
+      errorMsg = 'API rate limit or quota exceeded. Please:\n' +
+        '  1. Check your Cursor subscription\n' +
+        '  2. Wait a few minutes and try again\n\n' +
+        `Details: ${errorMsg}`;
+    }
+    
+    // Check for model errors
+    if (errorMsg.includes('model')) {
+      errorMsg = `Model error (requested: ${model || 'default'}). ` +
+        'Please check if the model is available in your Cursor subscription.\n\n' +
+        `Details: ${errorMsg}`;
+    }
+    
     return {
       ok: false,
       exitCode: res.status,
-      error: msg,
+      error: errorMsg,
     };
   }
   
@@ -251,8 +349,35 @@ async function runTask({
  * Run all tasks in sequence
  */
 async function runTasks(config, runDir) {
+  const { checkCursorAuth, printAuthHelp } = require('../utils/cursor-agent');
+  
+  // Ensure cursor-agent is installed
   ensureCursorAgent();
   
+  // Check authentication before starting
+  logger.info('Checking Cursor authentication...');
+  const authStatus = checkCursorAuth();
+  
+  if (!authStatus.authenticated) {
+    logger.error('❌ Cursor authentication failed');
+    logger.error(`   ${authStatus.message}`);
+    
+    if (authStatus.details) {
+      logger.error(`   Details: ${authStatus.details}`);
+    }
+    
+    if (authStatus.help) {
+      logger.error(`   ${authStatus.help}`);
+    }
+    
+    console.log('');
+    printAuthHelp();
+    
+    throw new Error('Cursor authentication required. Please authenticate and try again.');
+  }
+  
+  logger.success('✓ Cursor authentication OK');
+  
   const repoRoot = git.getRepoRoot();
   const pipelineBranch = config.pipelineBranch || `${config.branchPrefix}${Date.now().toString(36)}`;
   const worktreeDir = path.join(repoRoot, config.worktreeRoot || '_cursorflow/worktrees', pipelineBranch);
@@ -269,6 +394,7 @@ async function runTasks(config, runDir) {
   });
   
   // Create chat
+  logger.info('Creating chat session...');
   const chatId = cursorAgentCreateChat();
   
   // Save initial state
@@ -341,3 +467,55 @@ module.exports = {
   runTasks,
   runTask,
 };
+
+/**
+ * CLI entry point
+ */
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  
+  if (args.length < 1) {
+    console.error('Usage: node runner.js <tasks-file> --run-dir <dir> --executor <executor>');
+    process.exit(1);
+  }
+  
+  const tasksFile = args[0];
+  const runDirIdx = args.indexOf('--run-dir');
+  const executorIdx = args.indexOf('--executor');
+  
+  const runDir = runDirIdx >= 0 ? args[runDirIdx + 1] : '.';
+  const executor = executorIdx >= 0 ? args[executorIdx + 1] : 'cursor-agent';
+  
+  if (!fs.existsSync(tasksFile)) {
+    console.error(`Tasks file not found: ${tasksFile}`);
+    process.exit(1);
+  }
+  
+  // Load tasks configuration
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(tasksFile, 'utf8'));
+  } catch (error) {
+    console.error(`Failed to load tasks file: ${error.message}`);
+    process.exit(1);
+  }
+  
+  // Add dependency policy defaults
+  config.dependencyPolicy = config.dependencyPolicy || {
+    allowDependencyChange: false,
+    lockfileReadOnly: true,
+  };
+  
+  // Run tasks
+  runTasks(config, runDir)
+    .then(() => {
+      process.exit(0);
+    })
+    .catch(error => {
+      console.error(`Runner failed: ${error.message}`);
+      if (process.env.DEBUG) {
+        console.error(error.stack);
+      }
+      process.exit(1);
+    });
+}