zyflow 0.6.4

package/mcp-server/triggers/event-listener.ts

@@ -0,0 +1,331 @@
+/**
+ * Event Listener Trigger
+ *
+ * GitHub CI, Sentry 등 외부 이벤트 폴링 및 트리거
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import type { TriggerConfig, EventTriggerType, TaskType } from '../post-task-types.js';
+import { loadTriggerConfig, parseInterval } from '../trigger-config.js';
+import { getPostTaskRunner } from '../post-task-runner.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * 이벤트 리스너 상태
+ */
+interface ListenerState {
+  isRunning: boolean;
+  intervals: Map<string, NodeJS.Timeout>;
+  lastCheck: Map<string, Date>;
+  lastKnownState: Map<string, string>;
+}
+
+/**
+ * 전역 리스너 상태
+ */
+const listenerState: ListenerState = {
+  isRunning: false,
+  intervals: new Map(),
+  lastCheck: new Map(),
+  lastKnownState: new Map(),
+};
+
+/**
+ * GitHub CI 상태 폴링
+ */
+async function pollGitHubCI(projectPath: string): Promise<{
+  hasNewFailure: boolean;
+  details?: string;
+}> {
+  try {
+    // 최근 워크플로우 실행 상태 조회
+    const { stdout } = await execAsync(
+      'gh run list --limit 1 --json databaseId,status,conclusion',
+      { cwd: projectPath, maxBuffer: 1024 * 1024 }
+    );
+
+    const runs = JSON.parse(stdout);
+    if (runs.length === 0) {
+      return { hasNewFailure: false };
+    }
+
+    const latestRun = runs[0];
+    const runKey = `github-ci-${latestRun.databaseId}`;
+    const previousState = listenerState.lastKnownState.get('github-ci');
+
+    // 상태 업데이트
+    listenerState.lastKnownState.set('github-ci', latestRun.databaseId + '-' + latestRun.conclusion);
+
+    // 새로운 실패 감지
+    if (
+      latestRun.conclusion === 'failure' &&
+      previousState !== latestRun.databaseId + '-failure'
+    ) {
+      return {
+        hasNewFailure: true,
+        details: `Run ${latestRun.databaseId} failed`,
+      };
+    }
+
+    return { hasNewFailure: false };
+  } catch {
+    return { hasNewFailure: false };
+  }
+}
+
+/**
+ * Sentry 이슈 폴링
+ */
+async function pollSentry(projectPath: string): Promise<{
+  hasNewIssue: boolean;
+  details?: string;
+}> {
+  try {
+    // Sentry API로 최근 이슈 조회
+    const token = process.env.SENTRY_AUTH_TOKEN;
+    const org = process.env.SENTRY_ORG;
+    const project = process.env.SENTRY_PROJECT;
+
+    if (!token || !org || !project) {
+      return { hasNewIssue: false };
+    }
+
+    const response = await fetch(
+      `https://sentry.io/api/0/projects/${org}/${project}/issues/?query=is:unresolved&limit=1`,
+      {
+        headers: {
+          Authorization: `Bearer ${token}`,
+        },
+      }
+    );
+
+    if (!response.ok) {
+      return { hasNewIssue: false };
+    }
+
+    const issues = await response.json() as { id: string; shortId: string; title: string }[];
+
+    if (issues.length === 0) {
+      return { hasNewIssue: false };
+    }
+
+    const latestIssue = issues[0];
+    const previousState = listenerState.lastKnownState.get('sentry');
+
+    // 상태 업데이트
+    listenerState.lastKnownState.set('sentry', latestIssue.id);
+
+    // 새로운 이슈 감지
+    if (previousState !== latestIssue.id && previousState !== undefined) {
+      return {
+        hasNewIssue: true,
+        details: `New issue: ${latestIssue.shortId} - ${latestIssue.title}`,
+      };
+    }
+
+    return { hasNewIssue: false };
+  } catch {
+    return { hasNewIssue: false };
+  }
+}
+
+/**
+ * 이벤트에 따른 작업 실행
+ */
+async function triggerTasksForEvent(
+  projectPath: string,
+  eventType: EventTriggerType,
+  details?: string
+): Promise<void> {
+  const config = await loadTriggerConfig(projectPath);
+  const tasks = config.events?.[eventType];
+
+  if (!tasks || tasks.length === 0) {
+    console.log(`[EventListener] No tasks configured for event: ${eventType}`);
+    return;
+  }
+
+  console.log(`[EventListener] Triggering tasks for ${eventType}: ${tasks.join(', ')}`);
+  if (details) {
+    console.log(`[EventListener] Details: ${details}`);
+  }
+
+  const runner = getPostTaskRunner(projectPath);
+
+  try {
+    const result = await runner.run({
+      tasks,
+      projectPath,
+    });
+
+    console.log(`[EventListener] Completed: ${result.tasksSucceeded}/${result.tasksRun} tasks succeeded`);
+  } catch (error) {
+    console.error('[EventListener] Failed to run tasks:', error);
+  }
+}
+
+/**
+ * GitHub CI 폴링 시작
+ */
+function startGitHubCIPolling(projectPath: string, interval: number): void {
+  const poll = async () => {
+    listenerState.lastCheck.set('github-ci', new Date());
+    const result = await pollGitHubCI(projectPath);
+
+    if (result.hasNewFailure) {
+      await triggerTasksForEvent(projectPath, 'ci-failure', result.details);
+    }
+  };
+
+  // 즉시 실행
+  poll();
+
+  // 주기적 폴링
+  const intervalId = setInterval(poll, interval);
+  listenerState.intervals.set('github-ci', intervalId);
+}
+
+/**
+ * Sentry 폴링 시작
+ */
+function startSentryPolling(projectPath: string, interval: number): void {
+  const poll = async () => {
+    listenerState.lastCheck.set('sentry', new Date());
+    const result = await pollSentry(projectPath);
+
+    if (result.hasNewIssue) {
+      await triggerTasksForEvent(projectPath, 'sentry-issue', result.details);
+    }
+  };
+
+  // 즉시 실행
+  poll();
+
+  // 주기적 폴링
+  const intervalId = setInterval(poll, interval);
+  listenerState.intervals.set('sentry', intervalId);
+}
+
+/**
+ * 이벤트 리스너 시작
+ */
+export async function startEventListener(projectPath: string): Promise<{
+  success: boolean;
+  message: string;
+  listeners: string[];
+}> {
+  if (listenerState.isRunning) {
+    return {
+      success: false,
+      message: 'Event listener is already running',
+      listeners: Array.from(listenerState.intervals.keys()),
+    };
+  }
+
+  const config = await loadTriggerConfig(projectPath);
+  const listeners: string[] = [];
+
+  listenerState.isRunning = true;
+
+  // GitHub CI 폴링
+  if (config.polling?.['github-ci']?.enabled) {
+    const interval = parseInterval(config.polling['github-ci'].interval);
+    startGitHubCIPolling(projectPath, interval);
+    listeners.push('github-ci');
+  }
+
+  // Sentry 폴링
+  if (config.polling?.sentry?.enabled) {
+    const interval = parseInterval(config.polling.sentry.interval);
+    startSentryPolling(projectPath, interval);
+    listeners.push('sentry');
+  }
+
+  if (listeners.length === 0) {
+    listenerState.isRunning = false;
+    return {
+      success: false,
+      message: 'No event listeners configured or enabled',
+      listeners: [],
+    };
+  }
+
+  return {
+    success: true,
+    message: `Started ${listeners.length} event listener(s)`,
+    listeners,
+  };
+}
+
+/**
+ * 이벤트 리스너 중지
+ */
+export function stopEventListener(): { success: boolean; message: string } {
+  if (!listenerState.isRunning) {
+    return {
+      success: false,
+      message: 'Event listener is not running',
+    };
+  }
+
+  // 모든 인터벌 취소
+  for (const intervalId of listenerState.intervals.values()) {
+    clearInterval(intervalId);
+  }
+
+  listenerState.intervals.clear();
+  listenerState.isRunning = false;
+
+  return {
+    success: true,
+    message: 'Event listener stopped',
+  };
+}
+
+/**
+ * 이벤트 리스너 상태 조회
+ */
+export function getEventListenerStatus(): {
+  isRunning: boolean;
+  listeners: {
+    source: string;
+    lastCheck?: string;
+    lastKnownState?: string;
+  }[];
+} {
+  const listeners: {
+    source: string;
+    lastCheck?: string;
+    lastKnownState?: string;
+  }[] = [];
+
+  for (const source of listenerState.intervals.keys()) {
+    listeners.push({
+      source,
+      lastCheck: listenerState.lastCheck.get(source)?.toISOString(),
+      lastKnownState: listenerState.lastKnownState.get(source),
+    });
+  }
+
+  return {
+    isRunning: listenerState.isRunning,
+    listeners,
+  };
+}
+
+/**
+ * 수동 이벤트 트리거 (테스트용)
+ */
+export async function triggerEvent(
+  projectPath: string,
+  eventType: EventTriggerType
+): Promise<{ success: boolean; message: string }> {
+  await triggerTasksForEvent(projectPath, eventType, 'Manual trigger');
+
+  return {
+    success: true,
+    message: `Triggered event: ${eventType}`,
+  };
+}

package/mcp-server/triggers/git-hooks.ts

@@ -0,0 +1,283 @@
+/**
+ * Git Hooks Trigger
+ *
+ * Git hook을 통한 Post-Task 작업 트리거
+ */
+
+import { join } from 'path';
+import { writeFile, readFile, chmod, mkdir, access, unlink } from 'fs/promises';
+import type { TriggerConfig, GitHookType, TaskType } from '../post-task-types.js';
+import { loadTriggerConfig } from '../trigger-config.js';
+
+/**
+ * Git hooks 디렉토리
+ */
+const GIT_HOOKS_DIR = '.git/hooks';
+
+/**
+ * 지원하는 Git hook 타입
+ */
+const SUPPORTED_HOOKS: GitHookType[] = [
+  'pre-commit',
+  'pre-push',
+  'post-commit',
+  'post-merge',
+];
+
+/**
+ * 파일 존재 확인
+ */
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Hook 스크립트 생성
+ */
+function generateHookScript(hookType: GitHookType, tasks: TaskType[]): string {
+  const taskList = tasks.map((t) => `"${t}"`).join(', ');
+
+  return `#!/bin/sh
+# ZyFlow Post-Task Hook: ${hookType}
+# Generated automatically - do not edit manually
+# To modify, use: post_task_setup_hooks MCP tool
+
+# Run Post-Task Agent with specified tasks
+if command -v npx &> /dev/null; then
+  echo "[ZyFlow] Running ${hookType} tasks..."
+  npx zyflow post-task run --tasks ${tasks.join(',')} --hook ${hookType}
+else
+  echo "[ZyFlow] Warning: npx not found, skipping post-task"
+fi
+
+# Exit with the original exit code
+exit 0
+`;
+}
+
+/**
+ * Husky 스크립트 생성
+ */
+function generateHuskyScript(hookType: GitHookType, tasks: TaskType[]): string {
+  return `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+# ZyFlow Post-Task Hook: ${hookType}
+echo "[ZyFlow] Running ${hookType} tasks..."
+npx zyflow post-task run --tasks ${tasks.join(',')} --hook ${hookType}
+`;
+}
+
+/**
+ * Husky 사용 여부 확인
+ */
+async function isUsingHusky(projectPath: string): Promise<boolean> {
+  const huskyDir = join(projectPath, '.husky');
+  return fileExists(huskyDir);
+}
+
+/**
+ * Git hook 설치
+ */
+export async function installHook(
+  projectPath: string,
+  hookType: GitHookType,
+  tasks: TaskType[]
+): Promise<{ success: boolean; message: string; path: string }> {
+  try {
+    // Husky 사용 여부 확인
+    const useHusky = await isUsingHusky(projectPath);
+
+    let hookPath: string;
+    let script: string;
+
+    if (useHusky) {
+      // Husky 스크립트 생성
+      hookPath = join(projectPath, '.husky', hookType);
+      script = generateHuskyScript(hookType, tasks);
+    } else {
+      // 기본 Git hook 스크립트 생성
+      const hooksDir = join(projectPath, GIT_HOOKS_DIR);
+
+      // .git/hooks 디렉토리 확인
+      if (!(await fileExists(hooksDir))) {
+        await mkdir(hooksDir, { recursive: true });
+      }
+
+      hookPath = join(hooksDir, hookType);
+      script = generateHookScript(hookType, tasks);
+    }
+
+    // 기존 hook 백업
+    if (await fileExists(hookPath)) {
+      const existing = await readFile(hookPath, 'utf-8');
+
+      // ZyFlow가 생성한 hook이 아닌 경우 백업
+      if (!existing.includes('ZyFlow Post-Task Hook')) {
+        const backupPath = hookPath + '.zyflow-backup';
+        await writeFile(backupPath, existing, 'utf-8');
+      }
+    }
+
+    // Hook 스크립트 작성
+    await writeFile(hookPath, script, 'utf-8');
+    await chmod(hookPath, 0o755);
+
+    return {
+      success: true,
+      message: `Installed ${hookType} hook with tasks: ${tasks.join(', ')}`,
+      path: hookPath,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: error instanceof Error ? error.message : String(error),
+      path: '',
+    };
+  }
+}
+
+/**
+ * Git hook 제거
+ */
+export async function uninstallHook(
+  projectPath: string,
+  hookType: GitHookType
+): Promise<{ success: boolean; message: string }> {
+  try {
+    const useHusky = await isUsingHusky(projectPath);
+
+    const hookPath = useHusky
+      ? join(projectPath, '.husky', hookType)
+      : join(projectPath, GIT_HOOKS_DIR, hookType);
+
+    if (await fileExists(hookPath)) {
+      const content = await readFile(hookPath, 'utf-8');
+
+      // ZyFlow가 생성한 hook인지 확인
+      if (content.includes('ZyFlow Post-Task Hook')) {
+        await unlink(hookPath);
+
+        // 백업 복구
+        const backupPath = hookPath + '.zyflow-backup';
+        if (await fileExists(backupPath)) {
+          const backup = await readFile(backupPath, 'utf-8');
+          await writeFile(hookPath, backup, 'utf-8');
+          await chmod(hookPath, 0o755);
+          await unlink(backupPath);
+        }
+
+        return {
+          success: true,
+          message: `Uninstalled ${hookType} hook`,
+        };
+      } else {
+        return {
+          success: false,
+          message: `${hookType} hook was not installed by ZyFlow`,
+        };
+      }
+    }
+
+    return {
+      success: true,
+      message: `${hookType} hook not found`,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+/**
+ * 모든 설정된 hook 설치
+ */
+export async function installAllHooks(
+  projectPath: string
+): Promise<{ installed: string[]; failed: string[]; messages: string[] }> {
+  const config = await loadTriggerConfig(projectPath);
+  const installed: string[] = [];
+  const failed: string[] = [];
+  const messages: string[] = [];
+
+  if (!config.hooks) {
+    return { installed, failed, messages: ['No hooks configured'] };
+  }
+
+  for (const hookType of SUPPORTED_HOOKS) {
+    const tasks = config.hooks[hookType];
+
+    if (tasks && tasks.length > 0) {
+      const result = await installHook(projectPath, hookType, tasks);
+
+      if (result.success) {
+        installed.push(hookType);
+        messages.push(result.message);
+      } else {
+        failed.push(hookType);
+        messages.push(`Failed to install ${hookType}: ${result.message}`);
+      }
+    }
+  }
+
+  return { installed, failed, messages };
+}
+
+/**
+ * 모든 ZyFlow hook 제거
+ */
+export async function uninstallAllHooks(
+  projectPath: string
+): Promise<{ uninstalled: string[]; messages: string[] }> {
+  const uninstalled: string[] = [];
+  const messages: string[] = [];
+
+  for (const hookType of SUPPORTED_HOOKS) {
+    const result = await uninstallHook(projectPath, hookType);
+
+    if (result.success && result.message.includes('Uninstalled')) {
+      uninstalled.push(hookType);
+    }
+    messages.push(result.message);
+  }
+
+  return { uninstalled, messages };
+}
+
+/**
+ * 설치된 hook 목록 조회
+ */
+export async function listInstalledHooks(
+  projectPath: string
+): Promise<{ hookType: GitHookType; tasks: TaskType[]; isZyflow: boolean }[]> {
+  const hooks: { hookType: GitHookType; tasks: TaskType[]; isZyflow: boolean }[] = [];
+  const useHusky = await isUsingHusky(projectPath);
+
+  for (const hookType of SUPPORTED_HOOKS) {
+    const hookPath = useHusky
+      ? join(projectPath, '.husky', hookType)
+      : join(projectPath, GIT_HOOKS_DIR, hookType);
+
+    if (await fileExists(hookPath)) {
+      const content = await readFile(hookPath, 'utf-8');
+      const isZyflow = content.includes('ZyFlow Post-Task Hook');
+
+      // tasks 추출
+      const tasksMatch = content.match(/--tasks\s+([^\s]+)/);
+      const tasks = tasksMatch
+        ? (tasksMatch[1].split(',') as TaskType[])
+        : [];
+
+      hooks.push({ hookType, tasks, isZyflow });
+    }
+  }
+
+  return hooks;
+}