zyflow 0.6.4

package/server/git/status.ts

@@ -0,0 +1,322 @@
+/**
+ * Git 상태 파싱 유틸리티
+ * OpenSpec Change: integrate-git-workflow
+ */
+
+import { exec } from 'child_process'
+import { promisify } from 'util'
+
+const execAsync = promisify(exec)
+
+export interface GitStatus {
+  /** 현재 브랜치 이름 */
+  branch: string
+  /** 추적 중인 원격 브랜치 */
+  upstream: string | null
+  /** 원격보다 앞선 커밋 수 */
+  ahead: number
+  /** 원격보다 뒤처진 커밋 수 */
+  behind: number
+  /** staged 파일 목록 */
+  staged: string[]
+  /** modified 파일 목록 (unstaged) */
+  modified: string[]
+  /** untracked 파일 목록 */
+  untracked: string[]
+  /** deleted 파일 목록 */
+  deleted: string[]
+  /** 충돌 발생 여부 */
+  hasConflicts: boolean
+  /** 충돌 파일 목록 */
+  conflictFiles: string[]
+  /** 작업 중인 변경사항 존재 여부 */
+  isDirty: boolean
+  /** 마지막 커밋 해시 (short) */
+  lastCommitHash: string | null
+  /** 마지막 커밋 메시지 */
+  lastCommitMessage: string | null
+  /** Git 저장소 여부 */
+  isGitRepo: boolean
+}
+
+/**
+ * Git 상태 전체 조회
+ */
+export async function getGitStatus(cwd: string): Promise<GitStatus> {
+  const defaultStatus: GitStatus = {
+    branch: '',
+    upstream: null,
+    ahead: 0,
+    behind: 0,
+    staged: [],
+    modified: [],
+    untracked: [],
+    deleted: [],
+    hasConflicts: false,
+    conflictFiles: [],
+    isDirty: false,
+    lastCommitHash: null,
+    lastCommitMessage: null,
+    isGitRepo: false,
+  }
+
+  try {
+    // Git 저장소인지 확인
+    await execAsync('git rev-parse --git-dir', { cwd })
+    defaultStatus.isGitRepo = true
+  } catch {
+    return defaultStatus
+  }
+
+  try {
+    // 브랜치 정보 조회
+    const branchInfo = await getBranchInfo(cwd)
+    defaultStatus.branch = branchInfo.branch
+    defaultStatus.upstream = branchInfo.upstream
+    defaultStatus.ahead = branchInfo.ahead
+    defaultStatus.behind = branchInfo.behind
+
+    // 파일 상태 조회
+    const fileStatus = await getFileStatus(cwd)
+    defaultStatus.staged = fileStatus.staged
+    defaultStatus.modified = fileStatus.modified
+    defaultStatus.untracked = fileStatus.untracked
+    defaultStatus.deleted = fileStatus.deleted
+    defaultStatus.hasConflicts = fileStatus.conflictFiles.length > 0
+    defaultStatus.conflictFiles = fileStatus.conflictFiles
+    defaultStatus.isDirty =
+      fileStatus.staged.length > 0 ||
+      fileStatus.modified.length > 0 ||
+      fileStatus.untracked.length > 0 ||
+      fileStatus.deleted.length > 0
+
+    // 마지막 커밋 정보
+    const lastCommit = await getLastCommit(cwd)
+    defaultStatus.lastCommitHash = lastCommit.hash
+    defaultStatus.lastCommitMessage = lastCommit.message
+
+    return defaultStatus
+  } catch (error) {
+    console.error('Error getting git status:', error)
+    return defaultStatus
+  }
+}
+
+interface BranchInfo {
+  branch: string
+  upstream: string | null
+  ahead: number
+  behind: number
+}
+
+async function getBranchInfo(cwd: string): Promise<BranchInfo> {
+  const result: BranchInfo = {
+    branch: '',
+    upstream: null,
+    ahead: 0,
+    behind: 0,
+  }
+
+  try {
+    // 현재 브랜치
+    const { stdout: branchOut } = await execAsync('git branch --show-current', { cwd })
+    result.branch = branchOut.trim()
+
+    // detached HEAD 상태 처리
+    if (!result.branch) {
+      const { stdout: headOut } = await execAsync('git rev-parse --short HEAD', { cwd })
+      result.branch = `(HEAD detached at ${headOut.trim()})`
+      return result
+    }
+
+    // 추적 브랜치 및 ahead/behind
+    try {
+      const { stdout: trackingOut } = await execAsync(
+        `git rev-list --left-right --count ${result.branch}...@{upstream}`,
+        { cwd }
+      )
+      const [ahead, behind] = trackingOut.trim().split(/\s+/).map(Number)
+      result.ahead = ahead || 0
+      result.behind = behind || 0
+
+      // upstream 이름 조회
+      const { stdout: upstreamOut } = await execAsync(
+        `git rev-parse --abbrev-ref ${result.branch}@{upstream}`,
+        { cwd }
+      )
+      result.upstream = upstreamOut.trim()
+    } catch {
+      // upstream이 설정되지 않은 경우
+      result.upstream = null
+    }
+  } catch (error) {
+    console.error('Error getting branch info:', error)
+  }
+
+  return result
+}
+
+interface FileStatus {
+  staged: string[]
+  modified: string[]
+  untracked: string[]
+  deleted: string[]
+  conflictFiles: string[]
+}
+
+async function getFileStatus(cwd: string): Promise<FileStatus> {
+  const status: FileStatus = {
+    staged: [],
+    modified: [],
+    untracked: [],
+    deleted: [],
+    conflictFiles: [],
+  }
+
+  try {
+    // git status --porcelain=v1 로 파일 상태 조회
+    const { stdout } = await execAsync('git status --porcelain=v1', { cwd })
+    const lines = stdout.split('\n').filter(Boolean)
+
+    for (const line of lines) {
+      const indexStatus = line[0] // 스테이징 영역 상태
+      const workingStatus = line[1] // 워킹 디렉토리 상태
+      const file = line.slice(3)
+
+      // 충돌 파일 (UU, AA, DD 등)
+      if (indexStatus === 'U' || workingStatus === 'U') {
+        status.conflictFiles.push(file)
+        continue
+      }
+      if (indexStatus === 'A' && workingStatus === 'A') {
+        status.conflictFiles.push(file)
+        continue
+      }
+      if (indexStatus === 'D' && workingStatus === 'D') {
+        status.conflictFiles.push(file)
+        continue
+      }
+
+      // Staged 파일
+      if (indexStatus === 'M' || indexStatus === 'A' || indexStatus === 'R' || indexStatus === 'C') {
+        status.staged.push(file)
+      }
+      if (indexStatus === 'D') {
+        status.staged.push(file)
+      }
+
+      // Modified (unstaged)
+      if (workingStatus === 'M') {
+        status.modified.push(file)
+      }
+
+      // Deleted (unstaged)
+      if (workingStatus === 'D') {
+        status.deleted.push(file)
+      }
+
+      // Untracked
+      if (indexStatus === '?' && workingStatus === '?') {
+        status.untracked.push(file)
+      }
+    }
+  } catch (error) {
+    console.error('Error getting file status:', error)
+  }
+
+  return status
+}
+
+interface LastCommit {
+  hash: string | null
+  message: string | null
+}
+
+async function getLastCommit(cwd: string): Promise<LastCommit> {
+  try {
+    const { stdout: hashOut } = await execAsync('git rev-parse --short HEAD', { cwd })
+    const { stdout: msgOut } = await execAsync('git log -1 --format=%s', { cwd })
+
+    return {
+      hash: hashOut.trim(),
+      message: msgOut.trim(),
+    }
+  } catch {
+    return { hash: null, message: null }
+  }
+}
+
+/**
+ * 원격 저장소 업데이트 상태 확인 (fetch 후)
+ */
+export async function checkRemoteUpdates(cwd: string): Promise<{
+  hasUpdates: boolean
+  behind: number
+  remoteCommits: { hash: string; message: string }[]
+}> {
+  try {
+    // 먼저 fetch 실행
+    await execAsync('git fetch', { cwd, timeout: 30000 })
+
+    // ahead/behind 확인
+    const { stdout: countOut } = await execAsync(
+      'git rev-list --left-right --count HEAD...@{upstream}',
+      { cwd }
+    )
+    const [, behind] = countOut.trim().split(/\s+/).map(Number)
+
+    if (!behind || behind === 0) {
+      return { hasUpdates: false, behind: 0, remoteCommits: [] }
+    }
+
+    // 원격의 새 커밋 목록
+    const { stdout: logOut } = await execAsync(
+      `git log HEAD..@{upstream} --format="%h %s" -n 10`,
+      { cwd }
+    )
+    const remoteCommits = logOut
+      .trim()
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => {
+        const [hash, ...msgParts] = line.split(' ')
+        return { hash, message: msgParts.join(' ') }
+      })
+
+    return { hasUpdates: true, behind, remoteCommits }
+  } catch {
+    return { hasUpdates: false, behind: 0, remoteCommits: [] }
+  }
+}
+
+/**
+ * 충돌 가능성 사전 감지
+ */
+export async function detectPotentialConflicts(
+  cwd: string
+): Promise<{ hasPotentialConflicts: boolean; files: string[] }> {
+  try {
+    // dry-run merge로 충돌 파일 확인
+    const { stderr } = await execAsync('git merge --no-commit --no-ff @{upstream} 2>&1', { cwd })
+
+    // merge 취소
+    await execAsync('git merge --abort', { cwd }).catch(() => {})
+
+    if (stderr.includes('CONFLICT')) {
+      const conflictFiles = stderr
+        .split('\n')
+        .filter((line) => line.includes('CONFLICT'))
+        .map((line) => {
+          const match = line.match(/CONFLICT.*?:\s*(.+)/)
+          return match ? match[1].trim() : ''
+        })
+        .filter(Boolean)
+
+      return { hasPotentialConflicts: true, files: conflictFiles }
+    }
+
+    return { hasPotentialConflicts: false, files: [] }
+  } catch {
+    return { hasPotentialConflicts: false, files: [] }
+  }
+}

package/server/index.ts

@@ -0,0 +1,136 @@
+import 'dotenv/config'
+import { createServer } from 'http'
+import { app } from './app.js'
+import { initWebSocket } from './websocket.js'
+import { startTasksWatcher, stopTasksWatcher } from './watcher.js'
+import { startRemoteWatcher, stopAllRemoteWatchers } from './remote-watcher.js'
+import { startMoaiWatcher, stopMoaiWatcher } from './moai-watcher.js'
+// RAG 기능 삭제됨 - LEANN 외부 MCP 서버로 대체
+import { getActiveProject } from './config.js'
+import { syncFlowChanges, syncAllMoaiSpecs } from './flow-sync.js'
+import { getProcessManager } from './cli-adapter/process-manager.js'
+import { closeDb } from './tasks/index.js'
+
+// Port configuration: API_PORT > PORT > default 3100
+const PORT = parseInt(process.env.API_PORT || process.env.PORT || '3100', 10)
+
+// 처리되지 않은 예외 핸들러 - 서버 크래시 방지 및 로깅
+process.on('uncaughtException', (error) => {
+  console.error('[FATAL] Uncaught Exception:', error)
+  console.error('[FATAL] Stack:', error.stack)
+  // 심각한 오류이므로 graceful shutdown 시도
+  gracefulShutdown('uncaughtException')
+})
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('[ERROR] Unhandled Promise Rejection:', reason)
+  console.error('[ERROR] Promise:', promise)
+  // Promise 거부는 로깅만 하고 서버는 계속 실행
+})
+
+// HTTP 서버 생성 (Express + WebSocket 공유)
+const httpServer = createServer(app)
+
+// WebSocket 서버 초기화
+initWebSocket(httpServer)
+
+// 서버 시작
+httpServer.listen(PORT, '0.0.0.0', async () => {
+  console.log(`ZyFlow API server running on http://localhost:${PORT}`)
+
+  // 서버 시작 시 Flow changes DB 동기화 (파일 시스템 → DB)
+  try {
+    const syncResult = await syncFlowChanges()
+    if (syncResult.synced > 0) {
+      console.log(`[Sync] Flow changes synced: ${syncResult.created} created, ${syncResult.updated} updated (${syncResult.projects} projects)`)
+    } else {
+      console.log('[Sync] Flow changes sync completed (no changes)')
+    }
+  } catch (error) {
+    console.error('[Warning] Failed to sync flow changes:', error)
+  }
+
+  // MoAI SPEC 동기화 (.moai/specs/ → DB)
+  try {
+    const moaiResult = await syncAllMoaiSpecs()
+    if (moaiResult.totalCreated + moaiResult.totalUpdated > 0) {
+      console.log(`[Sync] MoAI SPECs synced: ${moaiResult.totalCreated} created, ${moaiResult.totalUpdated} updated (${moaiResult.projectsSynced} projects)`)
+    } else {
+      console.log('[Sync] MoAI SPECs sync completed (no changes)')
+    }
+  } catch (error) {
+    console.error('[Warning] Failed to sync MoAI SPECs:', error)
+  }
+
+  // 활성 프로젝트가 있으면 watcher 시작
+  try {
+    const project = await getActiveProject()
+    if (project && !project.remote?.serverId) {
+      // 로컬 프로젝트만 watcher 시작
+      startTasksWatcher(project.path, project.id)
+      startMoaiWatcher(project.path, project.id)
+      console.log('[Info] File watchers enabled for active project')
+
+    } else if (project?.remote?.serverId) {
+      // 원격 프로젝트는 remote watcher 시작
+      startRemoteWatcher(project, project.remote.serverId)
+      console.log('[Info] Remote file watcher enabled for active project')
+    } else {
+      console.log('[Info] No active project - file watcher not started')
+    }
+  } catch (error) {
+    console.error('[Warning] Failed to start file watcher:', error)
+  }
+})
+
+// Graceful shutdown 함수
+async function gracefulShutdown(reason: string) {
+  console.log(`\n[Shutdown] Initiating graceful shutdown (reason: ${reason})...`)
+
+  // 1. 새 요청 거부 - watcher 중지
+  stopTasksWatcher()
+  stopMoaiWatcher()
+  stopAllRemoteWatchers()
+
+  // 2. 활성 프로세스 정리
+  try {
+    const processManager = getProcessManager()
+    processManager.cleanup(0) // 모든 완료된 프로세스 즉시 정리
+    console.log('[Shutdown] Process manager cleaned up')
+  } catch {
+    // ProcessManager가 초기화되지 않은 경우 무시
+  }
+
+  // 3. DB 연결 종료
+  try {
+    closeDb()
+    console.log('[Shutdown] Database connection closed')
+  } catch {
+    // DB가 초기화되지 않은 경우 무시
+  }
+
+  // 4. HTTP 서버 종료
+  httpServer.close(() => {
+    console.log('[Shutdown] Server closed')
+    process.exit(reason === 'SIGINT' ? 0 : 1)
+  })
+
+  // 강제 종료 타임아웃 (10초)
+  setTimeout(() => {
+    console.error('[Shutdown] Forced exit after timeout')
+    process.exit(1)
+  }, 10000)
+}
+
+// 프로세스 자동 정리 (5분 이상 된 완료 프로세스 정리, 매 1분마다)
+setInterval(() => {
+  try {
+    const processManager = getProcessManager()
+    processManager.cleanup(300000) // 5분 이상 된 완료 프로세스 정리
+  } catch {
+    // ProcessManager가 초기화되지 않은 경우 무시
+  }
+}, 60000)
+
+process.on('SIGINT', () => gracefulShutdown('SIGINT'))
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'))

package/server/integrations/crypto.ts

@@ -0,0 +1,142 @@
+import { randomBytes, createCipheriv, createDecipheriv, scrypt } from 'crypto';
+import { promisify } from 'util';
+
+const scryptAsync = promisify(scrypt);
+
+// AES-256-GCM 설정
+const ALGORITHM = 'aes-256-gcm';
+const KEY_LENGTH = 32; // 256 bits
+const IV_LENGTH = 16; // 128 bits for GCM
+const AUTH_TAG_LENGTH = 16; // 128 bits
+const SALT_LENGTH = 32;
+
+/**
+ * 암호화된 데이터 구조
+ */
+export interface EncryptedData {
+  version: 1;
+  salt: string; // hex
+  iv: string; // hex
+  authTag: string; // hex
+  data: string; // hex
+}
+
+/**
+ * 마스터 키에서 암호화 키 파생
+ */
+async function deriveKey(masterKey: string, salt: Buffer): Promise<Buffer> {
+  return (await scryptAsync(masterKey, salt, KEY_LENGTH)) as Buffer;
+}
+
+/**
+ * 데이터 암호화 (AES-256-GCM)
+ *
+ * @param plaintext 암호화할 문자열
+ * @param masterKey 마스터 키
+ * @returns 암호화된 데이터 (JSON 직렬화 가능)
+ */
+export async function encrypt(plaintext: string, masterKey: string): Promise<EncryptedData> {
+  const salt = randomBytes(SALT_LENGTH);
+  const key = await deriveKey(masterKey, salt);
+  const iv = randomBytes(IV_LENGTH);
+
+  const cipher = createCipheriv(ALGORITHM, key, iv, { authTagLength: AUTH_TAG_LENGTH });
+
+  let encrypted = cipher.update(plaintext, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+
+  const authTag = cipher.getAuthTag();
+
+  return {
+    version: 1,
+    salt: salt.toString('hex'),
+    iv: iv.toString('hex'),
+    authTag: authTag.toString('hex'),
+    data: encrypted,
+  };
+}
+
+/**
+ * 데이터 복호화 (AES-256-GCM)
+ *
+ * @param encryptedData 암호화된 데이터
+ * @param masterKey 마스터 키
+ * @returns 복호화된 문자열
+ */
+export async function decrypt(encryptedData: EncryptedData, masterKey: string): Promise<string> {
+  if (encryptedData.version !== 1) {
+    throw new Error(`Unsupported encryption version: ${encryptedData.version}`);
+  }
+
+  const salt = Buffer.from(encryptedData.salt, 'hex');
+  const key = await deriveKey(masterKey, salt);
+  const iv = Buffer.from(encryptedData.iv, 'hex');
+  const authTag = Buffer.from(encryptedData.authTag, 'hex');
+
+  const decipher = createDecipheriv(ALGORITHM, key, iv, { authTagLength: AUTH_TAG_LENGTH });
+  decipher.setAuthTag(authTag);
+
+  let decrypted = decipher.update(encryptedData.data, 'hex', 'utf8');
+  decrypted += decipher.final('utf8');
+
+  return decrypted;
+}
+
+/**
+ * 객체 암호화 (JSON 직렬화 후 암호화)
+ */
+export async function encryptObject<T>(obj: T, masterKey: string): Promise<string> {
+  const json = JSON.stringify(obj);
+  const encrypted = await encrypt(json, masterKey);
+  return JSON.stringify(encrypted);
+}
+
+/**
+ * 객체 복호화 (복호화 후 JSON 파싱)
+ */
+export async function decryptObject<T>(encryptedString: string, masterKey: string): Promise<T> {
+  const encryptedData: EncryptedData = JSON.parse(encryptedString);
+  const json = await decrypt(encryptedData, masterKey);
+  return JSON.parse(json) as T;
+}
+
+/**
+ * 랜덤 마스터 키 생성
+ */
+export function generateMasterKey(): string {
+  return randomBytes(32).toString('hex');
+}
+
+/**
+ * 민감 정보 마스킹 (UI 표시용)
+ * 예: "ghp_xxxxxxxxxxxx" -> "ghp_...xxxx"
+ */
+export function maskSensitive(value: string, showChars: number = 4): string {
+  if (value.length <= showChars * 2) {
+    return '*'.repeat(value.length);
+  }
+
+  const prefix = value.slice(0, showChars);
+  const suffix = value.slice(-showChars);
+  return `${prefix}...${suffix}`;
+}
+
+/**
+ * 암호화된 문자열인지 확인
+ */
+export function isEncrypted(value: string): boolean {
+  try {
+    const parsed = JSON.parse(value);
+    return (
+      parsed &&
+      typeof parsed === 'object' &&
+      parsed.version === 1 &&
+      typeof parsed.salt === 'string' &&
+      typeof parsed.iv === 'string' &&
+      typeof parsed.authTag === 'string' &&
+      typeof parsed.data === 'string'
+    );
+  } catch {
+    return false;
+  }
+}