@triflux/core 10.0.0-alpha.1

package/hooks/mcp-config-watcher.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+// hooks/mcp-config-watcher.mjs — PostToolUse:Edit|Write 훅
+//
+// 감시 대상 MCP 설정 파일 변경을 감지해 stdio 서버를 즉시 차단/치환한다.
+// 경로가 watched_paths와 매칭되지 않으면 바로 종료해 일반 편집 성능에 영향이 없도록 한다.
+
+import { readFileSync } from "node:fs";
+import {
+  isWatchedPath,
+  loadRegistry,
+  remediate,
+  scanForStdioServers,
+} from "../scripts/lib/mcp-guard-engine.mjs";
+
+function readStdin() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function buildSystemMessage(filePath, stdioServers, result) {
+  const lines = [`[mcp-guard] 감시 대상 MCP 설정 변경 감지: ${filePath}`];
+
+  if (result.modified) {
+    const actionLabel = result.replacement ? "자동 치환" : "자동 제거";
+    lines.push(`[mcp-guard] stdio MCP ${actionLabel}: ${stdioServers.map((server) => server.name).join(", ")}`);
+
+    if (result.replacement?.name && result.replacement?.url) {
+      lines.push(`[mcp-guard] 대체 서버: ${result.replacement.name} -> ${result.replacement.url}`);
+    }
+
+    if (result.backupPath) {
+      lines.push(`[mcp-guard] 백업: ${result.backupPath}`);
+    }
+  }
+
+  for (const warning of result.warnings || []) {
+    lines.push(warning);
+  }
+
+  return lines.length > 0 ? lines.join("\n") : "";
+}
+
+function main() {
+  const raw = readStdin();
+  if (!raw.trim()) process.exit(0);
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  const toolName = input.tool_name || "";
+  if (toolName !== "Edit" && toolName !== "Write") process.exit(0);
+
+  const filePath = input.tool_input?.file_path || "";
+  if (!filePath || !isWatchedPath(filePath)) process.exit(0);
+
+  let registry;
+  try {
+    registry = loadRegistry();
+  } catch {
+    process.exit(0);
+  }
+
+  const stdioServers = scanForStdioServers(filePath);
+  if (stdioServers.length === 0) process.exit(0);
+
+  const result = remediate(filePath, stdioServers, registry.policies);
+  const systemMessage = buildSystemMessage(filePath, stdioServers, result);
+
+  if (systemMessage) {
+    process.stdout.write(JSON.stringify({ systemMessage }));
+  }
+}
+
+try {
+  main();
+} catch {
+  process.exit(0);
+}

package/hooks/pipeline-stop.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+// hooks/pipeline-stop.mjs — Stop 훅: 활성 파이프라인 감지 시 구조화 decision 반환
+//
+// Claude Code Stop 이벤트에서 실행.
+// 비터미널 단계의 파이프라인이 있으면 decision:"block" + reason으로 중단을 방지한다.
+// 파이프라인이 없으면 정상 종료를 허용한다.
+
+import { existsSync } from "node:fs";
+
+let getPipelineStateDbPath;
+let ensurePipelineTable;
+let listPipelineStates;
+try {
+  ({
+    getPipelineStateDbPath,
+    ensurePipelineTable,
+    listPipelineStates,
+  } = await import("../hub/pipeline/state.mjs"));
+} catch {
+  // hub/pipeline 모듈 없으면 훅 무동작
+  process.exit(0);
+}
+
+const PROJECT_ROOT = process.env.CLAUDE_CWD || process.cwd();
+const HUB_DB_PATH = getPipelineStateDbPath(PROJECT_ROOT);
+const TERMINAL = new Set(["complete", "failed"]);
+
+async function checkActivePipelines() {
+  if (!existsSync(HUB_DB_PATH)) return [];
+
+  try {
+    const { default: Database } = await import("better-sqlite3");
+
+    const db = new Database(HUB_DB_PATH, { readonly: true });
+    ensurePipelineTable(db);
+    const states = listPipelineStates(db);
+    db.close();
+
+    return states.filter((s) => !TERMINAL.has(s.phase));
+  } catch {
+    return [];
+  }
+}
+
+try {
+  const active = await checkActivePipelines();
+
+  if (active.length === 0) {
+    // 활성 파이프라인 없음 → 정상 종료 허용
+    process.exit(0);
+  }
+
+  // 활성 파이프라인 발견 → 구조화 decision으로 block
+  const lines = active.map(
+    (s) =>
+      `  - 팀 ${s.team_name}: ${s.phase} 단계 (fix: ${s.fix_attempt}/${s.fix_max}, ralph: ${s.ralph_iteration}/${s.ralph_max})`
+  );
+
+  const reason =
+    `[tfx-multi 파이프라인 진행 중]\n` +
+    `활성 파이프라인 ${active.length}개가 아직 완료되지 않았습니다:\n` +
+    `${lines.join("\n")}\n\n` +
+    `파이프라인을 이어서 진행하려면 /tfx-multi status 로 상태를 확인하세요.\n` +
+    `강제 종료하려면 /tfx-multi cancel 을 먼저 실행하세요.`;
+
+  // 구조화된 Stop hook 출력: decision + reason
+  const output = {
+    decision: "block",
+    reason,
+  };
+
+  process.stdout.write(JSON.stringify(output));
+} catch {
+  // 훅 실패 시 종료 허용
+  process.exit(0);
+}

package/hooks/safety-guard.mjs

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+// hooks/safety-guard.mjs — PreToolUse:Bash 훅
+//
+// 위험한 Bash 명령을 사전 차단(exit 2)하거나 경고(additionalContext)한다.
+// hooks.json에서 `if: "Bash(*)"` 필터와 함께 사용.
+//
+// 차단 레벨:
+//   BLOCK (exit 2)  — 복구 불가능한 파괴적 명령
+//   WARN  (allow + context) — 주의가 필요한 명령
+
+import { readFileSync } from "node:fs";
+
+// ── 차단 규칙 ──────────────────────────────────────────────
+const BLOCK_RULES = [
+  { pattern: /\brm\s+(-[^\s]*)?-rf?\s+[/~](?!tmp\b)(?!\S*node_modules)/i, reason: "루트/홈 디렉토리 rm -rf 차단" },
+  { pattern: /\brm\s+(-[^\s]*)?-rf?\s+\.\s*$/i, reason: "현재 디렉토리 rm -rf . 차단" },
+  { pattern: /\bgit\s+push\s+.*--force\s+.*\b(main|master)\b/i, reason: "main/master force push 차단" },
+  { pattern: /\bgit\s+push\s+--force\s*$/i, reason: "대상 미지정 force push 차단" },
+  { pattern: /\bgit\s+reset\s+--hard\s+origin\//i, reason: "remote reset --hard 차단 — 로컬 작업 소실 위험" },
+  { pattern: /\bdrop\s+(table|database|schema)\b/i, reason: "SQL DROP 차단" },
+  { pattern: /\btruncate\s+table\b/i, reason: "SQL TRUNCATE 차단" },
+  { pattern: /\bformat\s+[a-z]:/i, reason: "디스크 포맷 차단" },
+  { pattern: /\b(del|rmdir)\s+\/[sq]\b/i, reason: "Windows 재귀 삭제 차단" },
+  { pattern: /\bgit\s+clean\s+.*-fd/i, reason: "git clean -fd 차단 — 추적되지 않은 파일 소실 위험" },
+];
+
+// ── 경고 규칙 ──────────────────────────────────────────────
+const WARN_RULES = [
+  { pattern: /\bgit\s+push\b(?!.*--force)/i, warn: "git push 감지. 원격 저장소에 반영됩니다." },
+  { pattern: /\bgit\s+rebase\b/i, warn: "git rebase 감지. 커밋 히스토리가 변경됩니다." },
+  { pattern: /\bgit\s+branch\s+-[dD]\b/i, warn: "브랜치 삭제 감지." },
+  { pattern: /\bnpm\s+publish\b/i, warn: "npm publish 감지. 공개 레지스트리에 배포됩니다." },
+  { pattern: /\brm\s+(-[^\s]*)?-rf?\s/i, warn: "재귀 삭제 감지. 대상을 확인하세요." },
+  { pattern: /--no-verify\b/i, warn: "--no-verify 감지. 훅 건너뛰기는 권장하지 않습니다." },
+  { pattern: /\bchmod\s+777\b/i, warn: "chmod 777 감지. 보안 위험." },
+  { pattern: /\bcurl\s.*\|\s*(bash|sh)\b/i, warn: "curl | sh 감지. 원격 스크립트 실행 주의." },
+];
+
+function readStdin() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function main() {
+  const raw = readStdin();
+  if (!raw.trim()) process.exit(0);
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  if (input.tool_name !== "Bash") process.exit(0);
+
+  const command = (input.tool_input?.command || "").trim();
+  if (!command) process.exit(0);
+
+  // 1. BLOCK 체크 — exit 2로 차단
+  for (const rule of BLOCK_RULES) {
+    if (rule.pattern.test(command)) {
+      process.stderr.write(
+        `[triflux safety-guard] BLOCKED: ${rule.reason}\n` +
+          `명령어: ${command.slice(0, 120)}${command.length > 120 ? "..." : ""}\n` +
+          `이 명령은 실행할 수 없습니다. 안전한 대안을 사용하세요.`
+      );
+      process.exit(2);
+    }
+  }
+
+  // 2. WARN 체크 — allow + additionalContext
+  const warnings = [];
+  for (const rule of WARN_RULES) {
+    if (rule.pattern.test(command)) {
+      warnings.push(rule.warn);
+    }
+  }
+
+  if (warnings.length > 0) {
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "allow",
+        additionalContext:
+          `[safety-guard] ⚠ ${warnings.join(" | ")}\n` +
+          `명령어: ${command.slice(0, 200)}`,
+      },
+    };
+    process.stdout.write(JSON.stringify(output));
+    process.exit(0);
+  }
+
+  // 3. 안전한 명령 → 통과
+  process.exit(0);
+}
+
+try {
+  main();
+} catch {
+  // 훅 실패 시 블로킹하지 않음
+  process.exit(0);
+}

package/hooks/subagent-verifier.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// hooks/subagent-verifier.mjs — SubagentStop 훅
+//
+// 서브에이전트 완료 시 결과 품질을 체크한다:
+//   - 빈 결과 감지 → 재시도 제안
+//   - 에러 종료 감지 → 원인 분석 컨텍스트 주입
+//   - 과도한 토큰 사용 감지 → 효율성 알림
+
+import { readFileSync } from "node:fs";
+
+function readStdin() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function main() {
+  const raw = readStdin();
+  if (!raw.trim()) process.exit(0);
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  const agentType = input.agent_type || input.subagent_type || "unknown";
+  const result = input.tool_output || input.result || "";
+  const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+
+  const issues = [];
+
+  // 1. 빈 결과 체크
+  if (!resultStr.trim() || resultStr.trim().length < 20) {
+    issues.push(
+      `서브에이전트(${agentType})가 거의 빈 결과를 반환했습니다. ` +
+        "프롬프트를 더 구체적으로 작성하거나, 다른 subagent_type을 시도하세요."
+    );
+  }
+
+  // 2. 에러 키워드 감지
+  const errorPatterns = [
+    /error:|exception:|traceback|failed to|fatal:/i,
+    /❌|FAILED|ERROR/,
+  ];
+  const hasError = errorPatterns.some((p) => p.test(resultStr));
+  if (hasError && resultStr.length > 50) {
+    issues.push(
+      `서브에이전트(${agentType}) 결과에 에러 신호가 감지되었습니다. ` +
+        "결과를 검토하고, 필요 시 다른 접근 방식을 사용하세요."
+    );
+  }
+
+  // 3. 결과가 너무 길면 요약 필요 알림
+  if (resultStr.length > 15000) {
+    issues.push(
+      `서브에이전트(${agentType}) 결과가 ${Math.round(resultStr.length / 1000)}K 자입니다. ` +
+        "핵심만 추출하여 컨텍스트 윈도우를 절약하세요."
+    );
+  }
+
+  if (issues.length === 0) process.exit(0);
+
+  const output = {
+    systemMessage:
+      `[subagent-verifier] ${agentType} 완료 — 주의사항:\n` +
+      issues.map((i) => `  → ${i}`).join("\n"),
+  };
+
+  process.stdout.write(JSON.stringify(output));
+}
+
+try {
+  main();
+} catch {
+  process.exit(0);
+}

package/hub/assign-callbacks.mjs

@@ -0,0 +1,133 @@
+// hub/assign-callbacks.mjs — assign job 상태 변경용 Named Pipe/Unix socket 브로드캐스터
+
+import net from 'node:net';
+import { existsSync, unlinkSync } from 'node:fs';
+import { IS_WINDOWS, pipePath } from './platform.mjs';
+
+export function getAssignCallbackPipePath(sessionId = process.pid) {
+  return pipePath('triflux-assign-callback', sessionId);
+}
+
+function buildAssignCallbackEvent(event = {}, row = null) {
+  const source = row || event || {};
+  const updatedAtMs = Number(source.updated_at_ms);
+  const createdAtMs = Number(source.created_at_ms);
+  const timestampMs = Number.isFinite(updatedAtMs)
+    ? updatedAtMs
+    : (Number.isFinite(createdAtMs) ? createdAtMs : Date.now());
+
+  return {
+    event: 'assign_job_status',
+    job_id: source.job_id || event.job_id || null,
+    supervisor_agent: source.supervisor_agent || null,
+    worker_agent: source.worker_agent || null,
+    topic: source.topic || null,
+    task: source.task || null,
+    status: source.status || event.status || null,
+    attempt: Number.isFinite(Number(source.attempt)) ? Number(source.attempt) : null,
+    retry_count: Number.isFinite(Number(source.retry_count)) ? Number(source.retry_count) : null,
+    max_retries: Number.isFinite(Number(source.max_retries)) ? Number(source.max_retries) : null,
+    priority: Number.isFinite(Number(source.priority)) ? Number(source.priority) : null,
+    ttl_ms: Number.isFinite(Number(source.ttl_ms)) ? Number(source.ttl_ms) : null,
+    timeout_ms: Number.isFinite(Number(source.timeout_ms)) ? Number(source.timeout_ms) : null,
+    deadline_ms: Number.isFinite(Number(source.deadline_ms)) ? Number(source.deadline_ms) : null,
+    trace_id: source.trace_id || null,
+    correlation_id: source.correlation_id || null,
+    last_message_id: source.last_message_id || null,
+    result: Object.prototype.hasOwnProperty.call(source, 'result')
+      ? source.result
+      : (Object.prototype.hasOwnProperty.call(event, 'result') ? event.result : null),
+    error: Object.prototype.hasOwnProperty.call(source, 'error')
+      ? source.error
+      : (Object.prototype.hasOwnProperty.call(event, 'error') ? event.error : null),
+    created_at_ms: Number.isFinite(createdAtMs) ? createdAtMs : null,
+    updated_at_ms: Number.isFinite(updatedAtMs) ? updatedAtMs : null,
+    started_at_ms: Number.isFinite(Number(source.started_at_ms)) ? Number(source.started_at_ms) : null,
+    completed_at_ms: Number.isFinite(Number(source.completed_at_ms)) ? Number(source.completed_at_ms) : null,
+    last_retry_at_ms: Number.isFinite(Number(source.last_retry_at_ms)) ? Number(source.last_retry_at_ms) : null,
+    timestamp: new Date(timestampMs).toISOString(),
+  };
+}
+
+export function createAssignCallbackServer({ store = null, sessionId = process.pid } = {}) {
+  const pipePath = getAssignCallbackPipePath(sessionId);
+  const clients = new Set();
+  let server = null;
+  let detachStoreListener = null;
+
+  function removeSocket(socket) {
+    if (!socket) return;
+    clients.delete(socket);
+    try { socket.destroy(); } catch {}
+  }
+
+  function broadcast(event) {
+    const frame = `${JSON.stringify(event)}\n`;
+    for (const socket of Array.from(clients)) {
+      if (!socket.writable || socket.destroyed) {
+        removeSocket(socket);
+        continue;
+      }
+      try {
+        socket.write(frame);
+      } catch {
+        removeSocket(socket);
+      }
+    }
+  }
+
+  return {
+    path: pipePath,
+    getStatus() {
+      return {
+        path: pipePath,
+        clients: clients.size,
+      };
+    },
+    async start() {
+      if (server) return { path: pipePath };
+      if (!IS_WINDOWS && existsSync(pipePath)) {
+        try { unlinkSync(pipePath); } catch {}
+      }
+
+      server = net.createServer((socket) => {
+        clients.add(socket);
+        socket.setEncoding('utf8');
+        socket.on('error', () => removeSocket(socket));
+        socket.on('close', () => removeSocket(socket));
+      });
+
+      await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(pipePath, () => {
+          server?.off('error', reject);
+          resolve();
+        });
+      });
+
+      if (store?.onAssignStatusChange && !detachStoreListener) {
+        detachStoreListener = store.onAssignStatusChange((event, row) => {
+          broadcast(buildAssignCallbackEvent(event, row));
+        });
+      }
+
+      return { path: pipePath };
+    },
+    async stop() {
+      if (detachStoreListener) {
+        try { detachStoreListener(); } catch {}
+        detachStoreListener = null;
+      }
+      if (!server) return;
+      for (const socket of Array.from(clients)) {
+        removeSocket(socket);
+      }
+      await new Promise((resolve) => server.close(resolve));
+      server = null;
+      if (!IS_WINDOWS && existsSync(pipePath)) {
+        try { unlinkSync(pipePath); } catch {}
+      }
+    },
+    broadcast,
+  };
+}