zyflow 0.6.4

package/mcp-server/trigger-config.ts

@@ -0,0 +1,288 @@
+/**
+ * Trigger Configuration
+ *
+ * .zyflow/triggers.json 스키마 정의 및 설정 로더
+ */
+
+import { join } from 'path';
+import { readFile, writeFile, mkdir, access } from 'fs/promises';
+import type { TriggerConfig, TaskType } from './post-task-types.js';
+import { DEFAULT_TRIGGER_CONFIG } from './post-task-types.js';
+
+/**
+ * 트리거 설정 파일 경로
+ */
+const TRIGGER_CONFIG_FILE = '.zyflow/triggers.json';
+
+/**
+ * 파일 존재 확인
+ */
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 트리거 설정 로드
+ */
+export async function loadTriggerConfig(projectPath: string): Promise<TriggerConfig> {
+  const configPath = join(projectPath, TRIGGER_CONFIG_FILE);
+
+  try {
+    if (await fileExists(configPath)) {
+      const content = await readFile(configPath, 'utf-8');
+      const config = JSON.parse(content) as Partial<TriggerConfig>;
+
+      // 기본값과 병합
+      return {
+        hooks: { ...DEFAULT_TRIGGER_CONFIG.hooks, ...config.hooks },
+        schedule: config.schedule || DEFAULT_TRIGGER_CONFIG.schedule,
+        events: { ...DEFAULT_TRIGGER_CONFIG.events, ...config.events },
+        polling: { ...DEFAULT_TRIGGER_CONFIG.polling, ...config.polling },
+      };
+    }
+  } catch (error) {
+    console.error('Failed to load trigger config:', error);
+  }
+
+  return { ...DEFAULT_TRIGGER_CONFIG };
+}
+
+/**
+ * 트리거 설정 저장
+ */
+export async function saveTriggerConfig(
+  projectPath: string,
+  config: TriggerConfig
+): Promise<void> {
+  const configPath = join(projectPath, TRIGGER_CONFIG_FILE);
+  const dir = join(projectPath, '.zyflow');
+
+  await mkdir(dir, { recursive: true });
+  await writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+/**
+ * 기본 트리거 설정으로 초기화
+ */
+export async function initTriggerConfig(projectPath: string): Promise<TriggerConfig> {
+  const config = { ...DEFAULT_TRIGGER_CONFIG };
+  await saveTriggerConfig(projectPath, config);
+  return config;
+}
+
+/**
+ * Hook에 작업 추가
+ */
+export async function addTaskToHook(
+  projectPath: string,
+  hook: keyof NonNullable<TriggerConfig['hooks']>,
+  task: TaskType
+): Promise<TriggerConfig> {
+  const config = await loadTriggerConfig(projectPath);
+
+  if (!config.hooks) {
+    config.hooks = {};
+  }
+
+  if (!config.hooks[hook]) {
+    config.hooks[hook] = [];
+  }
+
+  if (!config.hooks[hook]!.includes(task)) {
+    config.hooks[hook]!.push(task);
+  }
+
+  await saveTriggerConfig(projectPath, config);
+  return config;
+}
+
+/**
+ * Hook에서 작업 제거
+ */
+export async function removeTaskFromHook(
+  projectPath: string,
+  hook: keyof NonNullable<TriggerConfig['hooks']>,
+  task: TaskType
+): Promise<TriggerConfig> {
+  const config = await loadTriggerConfig(projectPath);
+
+  if (config.hooks && config.hooks[hook]) {
+    config.hooks[hook] = config.hooks[hook]!.filter((t) => t !== task);
+  }
+
+  await saveTriggerConfig(projectPath, config);
+  return config;
+}
+
+/**
+ * 스케줄 추가
+ */
+export async function addSchedule(
+  projectPath: string,
+  cron: string,
+  tasks: TaskType[],
+  description?: string
+): Promise<TriggerConfig> {
+  const config = await loadTriggerConfig(projectPath);
+
+  if (!config.schedule) {
+    config.schedule = [];
+  }
+
+  // 중복 cron 확인
+  const existing = config.schedule.find((s) => s.cron === cron);
+  if (existing) {
+    // 기존 스케줄에 작업 추가
+    for (const task of tasks) {
+      if (!existing.tasks.includes(task)) {
+        existing.tasks.push(task);
+      }
+    }
+    if (description) {
+      existing.description = description;
+    }
+  } else {
+    config.schedule.push({ cron, tasks, description });
+  }
+
+  await saveTriggerConfig(projectPath, config);
+  return config;
+}
+
+/**
+ * 스케줄 제거
+ */
+export async function removeSchedule(
+  projectPath: string,
+  cron: string
+): Promise<TriggerConfig> {
+  const config = await loadTriggerConfig(projectPath);
+
+  if (config.schedule) {
+    config.schedule = config.schedule.filter((s) => s.cron !== cron);
+  }
+
+  await saveTriggerConfig(projectPath, config);
+  return config;
+}
+
+/**
+ * 이벤트에 작업 추가
+ */
+export async function addTaskToEvent(
+  projectPath: string,
+  event: keyof NonNullable<TriggerConfig['events']>,
+  task: TaskType
+): Promise<TriggerConfig> {
+  const config = await loadTriggerConfig(projectPath);
+
+  if (!config.events) {
+    config.events = {};
+  }
+
+  if (!config.events[event]) {
+    config.events[event] = [];
+  }
+
+  if (!config.events[event]!.includes(task)) {
+    config.events[event]!.push(task);
+  }
+
+  await saveTriggerConfig(projectPath, config);
+  return config;
+}
+
+/**
+ * 폴링 설정 업데이트
+ */
+export async function updatePollingConfig(
+  projectPath: string,
+  source: 'github-ci' | 'sentry',
+  config: { interval: string; enabled: boolean }
+): Promise<TriggerConfig> {
+  const triggerConfig = await loadTriggerConfig(projectPath);
+
+  if (!triggerConfig.polling) {
+    triggerConfig.polling = {};
+  }
+
+  triggerConfig.polling[source] = config;
+
+  await saveTriggerConfig(projectPath, triggerConfig);
+  return triggerConfig;
+}
+
+/**
+ * 설정 유효성 검사
+ */
+export function validateTriggerConfig(config: TriggerConfig): {
+  valid: boolean;
+  errors: string[];
+} {
+  const errors: string[] = [];
+
+  // Cron 표현식 검증
+  if (config.schedule) {
+    for (const schedule of config.schedule) {
+      if (!isValidCron(schedule.cron)) {
+        errors.push(`Invalid cron expression: ${schedule.cron}`);
+      }
+    }
+  }
+
+  // 폴링 간격 검증
+  if (config.polling) {
+    for (const [source, settings] of Object.entries(config.polling)) {
+      if (!isValidInterval(settings.interval)) {
+        errors.push(`Invalid polling interval for ${source}: ${settings.interval}`);
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Cron 표현식 유효성 검사 (간단한 검증)
+ */
+function isValidCron(cron: string): boolean {
+  const parts = cron.split(' ');
+  return parts.length === 5 || parts.length === 6;
+}
+
+/**
+ * 폴링 간격 유효성 검사
+ */
+function isValidInterval(interval: string): boolean {
+  return /^\d+[smh]$/.test(interval);
+}
+
+/**
+ * 간격 문자열을 밀리초로 변환
+ */
+export function parseInterval(interval: string): number {
+  const match = interval.match(/^(\d+)([smh])$/);
+  if (!match) return 60000; // 기본값 1분
+
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+
+  switch (unit) {
+    case 's':
+      return value * 1000;
+    case 'm':
+      return value * 60 * 1000;
+    case 'h':
+      return value * 60 * 60 * 1000;
+    default:
+      return 60000;
+  }
+}

package/mcp-server/trigger-router.ts

@@ -0,0 +1,305 @@
+/**
+ * Trigger Router
+ *
+ * 트리거 → 작업 매핑 및 실행 관리
+ */
+
+import type { TriggerType, TaskType, GitHookType, EventTriggerType } from './post-task-types.js';
+import { loadTriggerConfig } from './trigger-config.js';
+import { getPostTaskRunner } from './post-task-runner.js';
+
+/**
+ * 실행 큐 항목
+ */
+interface QueueItem {
+  id: string;
+  triggerType: TriggerType;
+  triggerSource: string;
+  tasks: TaskType[];
+  queuedAt: Date;
+  status: 'pending' | 'running' | 'completed' | 'failed';
+  result?: unknown;
+}
+
+/**
+ * 중복 실행 방지를 위한 키
+ */
+type DedupKey = string;
+
+/**
+ * 라우터 상태
+ */
+interface RouterState {
+  queue: QueueItem[];
+  recentDedup: Map<DedupKey, Date>;
+  isProcessing: boolean;
+  maxQueueSize: number;
+  dedupWindow: number; // ms
+}
+
+/**
+ * 전역 라우터 상태
+ */
+const routerState: RouterState = {
+  queue: [],
+  recentDedup: new Map(),
+  isProcessing: false,
+  maxQueueSize: 100,
+  dedupWindow: 60000, // 1분 이내 중복 실행 방지
+};
+
+/**
+ * 중복 실행 키 생성
+ */
+function createDedupKey(triggerType: TriggerType, triggerSource: string, tasks: TaskType[]): DedupKey {
+  return `${triggerType}:${triggerSource}:${tasks.sort().join(',')}`;
+}
+
+/**
+ * 중복 실행 확인
+ */
+function isDuplicate(dedupKey: DedupKey): boolean {
+  const lastRun = routerState.recentDedup.get(dedupKey);
+  if (!lastRun) return false;
+
+  const elapsed = Date.now() - lastRun.getTime();
+  return elapsed < routerState.dedupWindow;
+}
+
+/**
+ * 중복 방지 기록 업데이트
+ */
+function updateDedup(dedupKey: DedupKey): void {
+  routerState.recentDedup.set(dedupKey, new Date());
+
+  // 오래된 기록 정리
+  const now = Date.now();
+  for (const [key, date] of routerState.recentDedup.entries()) {
+    if (now - date.getTime() > routerState.dedupWindow * 2) {
+      routerState.recentDedup.delete(key);
+    }
+  }
+}
+
+/**
+ * 작업을 큐에 추가
+ */
+export function enqueue(
+  triggerType: TriggerType,
+  triggerSource: string,
+  tasks: TaskType[],
+  options?: { skipDedup?: boolean }
+): { success: boolean; message: string; itemId?: string } {
+  // 큐 크기 확인
+  if (routerState.queue.length >= routerState.maxQueueSize) {
+    return {
+      success: false,
+      message: 'Queue is full',
+    };
+  }
+
+  // 중복 확인
+  const dedupKey = createDedupKey(triggerType, triggerSource, tasks);
+  if (!options?.skipDedup && isDuplicate(dedupKey)) {
+    return {
+      success: false,
+      message: 'Duplicate execution prevented',
+    };
+  }
+
+  // 큐에 추가
+  const item: QueueItem = {
+    id: crypto.randomUUID(),
+    triggerType,
+    triggerSource,
+    tasks,
+    queuedAt: new Date(),
+    status: 'pending',
+  };
+
+  routerState.queue.push(item);
+  updateDedup(dedupKey);
+
+  // 큐 처리 시작
+  processQueue();
+
+  return {
+    success: true,
+    message: 'Task queued',
+    itemId: item.id,
+  };
+}
+
+/**
+ * 큐 처리
+ */
+async function processQueue(): Promise<void> {
+  if (routerState.isProcessing) return;
+
+  routerState.isProcessing = true;
+
+  while (true) {
+    const pendingItem = routerState.queue.find((item) => item.status === 'pending');
+    if (!pendingItem) break;
+
+    pendingItem.status = 'running';
+
+    try {
+      const runner = getPostTaskRunner();
+      const result = await runner.run({
+        tasks: pendingItem.tasks,
+      });
+
+      pendingItem.status = 'completed';
+      pendingItem.result = result;
+    } catch (error) {
+      pendingItem.status = 'failed';
+      pendingItem.result = { error: error instanceof Error ? error.message : String(error) };
+    }
+
+    // 완료된 항목 정리 (최근 10개만 유지)
+    const completed = routerState.queue.filter(
+      (item) => item.status === 'completed' || item.status === 'failed'
+    );
+    if (completed.length > 10) {
+      const toRemove = completed.slice(0, completed.length - 10);
+      routerState.queue = routerState.queue.filter((item) => !toRemove.includes(item));
+    }
+  }
+
+  routerState.isProcessing = false;
+}
+
+/**
+ * Git Hook 트리거 라우팅
+ */
+export async function routeGitHook(
+  projectPath: string,
+  hookType: GitHookType
+): Promise<{ success: boolean; message: string }> {
+  const config = await loadTriggerConfig(projectPath);
+  const tasks = config.hooks?.[hookType];
+
+  if (!tasks || tasks.length === 0) {
+    return {
+      success: false,
+      message: `No tasks configured for hook: ${hookType}`,
+    };
+  }
+
+  return enqueue('git-hook', hookType, tasks);
+}
+
+/**
+ * 이벤트 트리거 라우팅
+ */
+export async function routeEvent(
+  projectPath: string,
+  eventType: EventTriggerType
+): Promise<{ success: boolean; message: string }> {
+  const config = await loadTriggerConfig(projectPath);
+  const tasks = config.events?.[eventType];
+
+  if (!tasks || tasks.length === 0) {
+    return {
+      success: false,
+      message: `No tasks configured for event: ${eventType}`,
+    };
+  }
+
+  return enqueue('event', eventType, tasks);
+}
+
+/**
+ * 수동 트리거 라우팅
+ */
+export function routeManual(tasks: TaskType[]): { success: boolean; message: string; itemId?: string } {
+  return enqueue('manual', 'user', tasks, { skipDedup: true });
+}
+
+/**
+ * 스케줄 트리거 라우팅
+ */
+export function routeScheduled(
+  cronExpression: string,
+  tasks: TaskType[]
+): { success: boolean; message: string; itemId?: string } {
+  return enqueue('scheduled', cronExpression, tasks);
+}
+
+/**
+ * 큐 상태 조회
+ */
+export function getQueueStatus(): {
+  isProcessing: boolean;
+  queueLength: number;
+  pending: number;
+  running: number;
+  completed: number;
+  failed: number;
+  items: QueueItem[];
+} {
+  const pending = routerState.queue.filter((i) => i.status === 'pending').length;
+  const running = routerState.queue.filter((i) => i.status === 'running').length;
+  const completed = routerState.queue.filter((i) => i.status === 'completed').length;
+  const failed = routerState.queue.filter((i) => i.status === 'failed').length;
+
+  return {
+    isProcessing: routerState.isProcessing,
+    queueLength: routerState.queue.length,
+    pending,
+    running,
+    completed,
+    failed,
+    items: routerState.queue.slice(-20), // 최근 20개만
+  };
+}
+
+/**
+ * 큐 항목 조회
+ */
+export function getQueueItem(itemId: string): QueueItem | undefined {
+  return routerState.queue.find((item) => item.id === itemId);
+}
+
+/**
+ * 큐 정리
+ */
+export function clearQueue(): { success: boolean; cleared: number } {
+  const pendingCount = routerState.queue.filter((i) => i.status === 'pending').length;
+
+  // 실행 중인 항목을 제외하고 모두 제거
+  routerState.queue = routerState.queue.filter((item) => item.status === 'running');
+
+  return {
+    success: true,
+    cleared: pendingCount,
+  };
+}
+
+/**
+ * 중복 방지 윈도우 설정
+ */
+export function setDedupWindow(windowMs: number): void {
+  routerState.dedupWindow = windowMs;
+}
+
+/**
+ * 전체 트리거 상태 요약
+ */
+export function getTriggerSummary(): {
+  queue: ReturnType<typeof getQueueStatus>;
+  recentTriggers: { key: string; lastRun: string }[];
+} {
+  const recentTriggers = Array.from(routerState.recentDedup.entries())
+    .map(([key, date]) => ({
+      key,
+      lastRun: date.toISOString(),
+    }))
+    .slice(-10);
+
+  return {
+    queue: getQueueStatus(),
+    recentTriggers,
+  };
+}