triflux 3.2.0-dev.8 → 3.3.0-dev.1

package/hub/team/shared.mjs

@@ -0,0 +1,13 @@
+// hub/team/shared.mjs — 팀 모듈 공유 유틸리티
+// cli.mjs, dashboard.mjs 등에서 중복되던 상수/함수를 통합
+
+// ── ANSI 색상 상수 ──
+export const AMBER = "\x1b[38;5;214m";
+export const GREEN = "\x1b[38;5;82m";
+export const RED = "\x1b[38;5;196m";
+export const GRAY = "\x1b[38;5;245m";
+export const DIM = "\x1b[2m";
+export const BOLD = "\x1b[1m";
+export const RESET = "\x1b[0m";
+export const WHITE = "\x1b[97m";
+export const YELLOW = "\x1b[33m";

package/hub/team/staleState.mjs

@@ -0,0 +1,299 @@
+// hub/team/staleState.mjs
+// .omc/state 아래에 남은 stale team 상태를 탐지/정리한다.
+
+import { existsSync, readFileSync, readdirSync, rmSync, statSync, unlinkSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { dirname, join, resolve } from "node:path";
+
+export const TEAM_STATE_FILE_NAME = "team-state.json";
+export const STALE_TEAM_MAX_AGE_MS = 60 * 60 * 1000;
+
+function safeStat(path) {
+  try {
+    return statSync(path);
+  } catch {
+    return null;
+  }
+}
+
+function parseStartedAtMs(value) {
+  if (typeof value !== "string" || !value.trim()) return null;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function findPidCandidates(state) {
+  const pidSet = new Set();
+  const pushPid = (value) => {
+    const pid = Number(value);
+    if (Number.isInteger(pid) && pid > 0) pidSet.add(pid);
+  };
+
+  pushPid(state?.pid);
+  pushPid(state?.processId);
+  pushPid(state?.process_id);
+  pushPid(state?.leadPid);
+  pushPid(state?.lead_pid);
+  pushPid(state?.native?.supervisorPid);
+  pushPid(state?.native?.supervisor_pid);
+
+  return Array.from(pidSet);
+}
+
+function findSessionNames(state) {
+  const sessionNameSet = new Set();
+  const pushName = (value) => {
+    if (typeof value !== "string") return;
+    const trimmed = value.trim();
+    if (trimmed) sessionNameSet.add(trimmed);
+  };
+
+  pushName(state?.sessionName);
+  pushName(state?.session_name);
+  pushName(state?.native?.teamName);
+  pushName(state?.native?.team_name);
+
+  return Array.from(sessionNameSet);
+}
+
+function findProcessTokens(state, sessionId) {
+  const tokenSet = new Set();
+  const pushToken = (value) => {
+    if (typeof value !== "string") return;
+    const trimmed = value.trim();
+    if (trimmed.length >= 6) tokenSet.add(trimmed.toLowerCase());
+  };
+
+  pushToken(sessionId);
+  pushToken(state?.session_id);
+  pushToken(state?.sessionId);
+  pushToken(state?.teamName);
+  pushToken(state?.team_name);
+  pushToken(state?.name);
+  pushToken(state?.native?.teamName);
+  pushToken(state?.native?.team_name);
+
+  return Array.from(tokenSet);
+}
+
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function normalizeProcessEntries(processEntries = []) {
+  if (!Array.isArray(processEntries)) return [];
+
+  return processEntries.map((entry) => ({
+    pid: Number(entry?.pid ?? entry?.ProcessId ?? 0),
+    command: String(entry?.command ?? entry?.CommandLine ?? entry?.Name ?? "").toLowerCase(),
+  }));
+}
+
+function readProcessEntries() {
+  try {
+    if (process.platform === "win32") {
+      const raw = execFileSync(
+        "powershell",
+        [
+          "-NoProfile",
+          "-Command",
+          "$ErrorActionPreference='SilentlyContinue'; Get-CimInstance Win32_Process | Select-Object ProcessId,Name,CommandLine | ConvertTo-Json -Compress",
+        ],
+        {
+          encoding: "utf8",
+          timeout: 10000,
+          stdio: ["ignore", "pipe", "ignore"],
+          windowsHide: true,
+        },
+      ).trim();
+
+      if (!raw) return [];
+      const parsed = JSON.parse(raw);
+      return normalizeProcessEntries(Array.isArray(parsed) ? parsed : [parsed]);
+    }
+
+    const raw = execFileSync("ps", ["-ax", "-o", "pid=,command="], {
+      encoding: "utf8",
+      timeout: 10000,
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+
+    if (!raw) return [];
+    return raw
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => {
+        const match = /^(\d+)\s+(.*)$/.exec(line);
+        return {
+          pid: Number(match?.[1] || 0),
+          command: String(match?.[2] || "").toLowerCase(),
+        };
+      });
+  } catch {
+    return [];
+  }
+}
+
+function resolveLiveness(state, sessionId, liveSessionNames, processEntries) {
+  const pidCandidates = findPidCandidates(state);
+  for (const pid of pidCandidates) {
+    if (isPidAlive(pid)) {
+      return { active: true, reason: `pid:${pid}` };
+    }
+  }
+
+  const sessionNames = findSessionNames(state);
+  for (const sessionName of sessionNames) {
+    if (liveSessionNames.has(sessionName)) {
+      return { active: true, reason: `session:${sessionName}` };
+    }
+  }
+
+  const processTokens = findProcessTokens(state, sessionId);
+  if (processTokens.length > 0) {
+    const matched = processEntries.find((entry) => (
+      entry.pid > 0 && processTokens.some((token) => entry.command.includes(token))
+    ));
+    if (matched) {
+      return { active: true, reason: `command:${matched.pid}` };
+    }
+  }
+
+  return { active: false, reason: "process_missing" };
+}
+
+function collectTeamStateTargets(stateRoot) {
+  const targets = [];
+  const rootStateFile = join(stateRoot, TEAM_STATE_FILE_NAME);
+  if (existsSync(rootStateFile)) {
+    targets.push({
+      scope: "root",
+      sessionId: "root",
+      stateFile: rootStateFile,
+      cleanupPath: rootStateFile,
+      cleanupType: "file",
+    });
+  }
+
+  const sessionsDir = join(stateRoot, "sessions");
+  const sessionsStat = safeStat(sessionsDir);
+  if (!sessionsStat?.isDirectory()) {
+    return targets;
+  }
+
+  for (const entry of readdirSync(sessionsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const sessionDir = join(sessionsDir, entry.name);
+    const stateFile = join(sessionDir, TEAM_STATE_FILE_NAME);
+    if (!existsSync(stateFile)) continue;
+
+    targets.push({
+      scope: "session",
+      sessionId: entry.name,
+      stateFile,
+      cleanupPath: sessionDir,
+      cleanupType: "dir",
+    });
+  }
+
+  return targets;
+}
+
+export function findNearestOmcStateDir(startDir = process.cwd()) {
+  let currentDir = resolve(startDir);
+
+  while (true) {
+    const candidate = join(currentDir, ".omc", "state");
+    const candidateStat = safeStat(candidate);
+    if (candidateStat?.isDirectory()) {
+      return candidate;
+    }
+
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+
+export function inspectStaleOmcTeams(options = {}) {
+  const stateRoot = options.stateRoot || findNearestOmcStateDir(options.startDir || process.cwd());
+  if (!stateRoot) {
+    return { stateRoot: null, entries: [] };
+  }
+
+  const liveSessionNames = new Set(options.liveSessionNames || []);
+  const processEntries = normalizeProcessEntries(options.processEntries || readProcessEntries());
+  const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+  const maxAgeMs = Number.isFinite(options.maxAgeMs) ? options.maxAgeMs : STALE_TEAM_MAX_AGE_MS;
+  const targets = collectTeamStateTargets(stateRoot);
+  const entries = [];
+
+  for (const target of targets) {
+    let state = null;
+    try {
+      state = JSON.parse(readFileSync(target.stateFile, "utf8"));
+    } catch {
+      continue;
+    }
+
+    const fileStat = safeStat(target.stateFile);
+    const startedAtMs = parseStartedAtMs(state?.started_at)
+      ?? parseStartedAtMs(state?.startedAt)
+      ?? fileStat?.mtimeMs
+      ?? null;
+    const ageMs = startedAtMs == null ? null : Math.max(0, nowMs - startedAtMs);
+    const liveness = resolveLiveness(state, target.sessionId, liveSessionNames, processEntries);
+    const stale = ageMs != null && ageMs >= maxAgeMs && !liveness.active;
+
+    entries.push({
+      ...target,
+      teamName: state?.teamName || state?.team_name || state?.native?.teamName || state?.name || null,
+      state,
+      startedAtMs,
+      ageMs,
+      ageSec: ageMs == null ? null : Math.floor(ageMs / 1000),
+      active: liveness.active,
+      activeReason: liveness.reason,
+      stale,
+    });
+  }
+
+  return {
+    stateRoot,
+    entries: entries
+      .filter((entry) => entry.stale)
+      .sort((left, right) => (right.ageMs || 0) - (left.ageMs || 0)),
+  };
+}
+
+export function cleanupStaleOmcTeams(entries = []) {
+  let cleaned = 0;
+  let failed = 0;
+  const results = [];
+
+  for (const entry of entries) {
+    try {
+      if (entry.cleanupType === "dir") {
+        rmSync(entry.cleanupPath, { recursive: true, force: true });
+      } else {
+        unlinkSync(entry.cleanupPath);
+      }
+
+      cleaned += 1;
+      results.push({ ok: true, entry });
+    } catch (error) {
+      failed += 1;
+      results.push({ ok: false, entry, error });
+    }
+  }
+
+  return { cleaned, failed, results };
+}

package/hub/tools.mjs

@@ -8,15 +8,25 @@ import {
   teamTaskUpdate,
   teamSendMessage,
 } from './team/nativeProxy.mjs';
+import {
+  ensurePipelineTable,
+  createPipeline,
+} from './pipeline/index.mjs';
+import {
+  readPipelineState,
+  initPipelineState,
+  listPipelineStates,
+} from './pipeline/state.mjs';
 
 /**
  * MCP 도구 목록 생성
  * @param {object} store  — createStore() 반환
  * @param {object} router — createRouter() 반환
  * @param {object} hitl   — createHitlManager() 반환
+ * @param {object} pipe   — createPipeServer() 반환
  * @returns {Array<{name, description, inputSchema, handler}>}
  */
-export function createTools(store, router, hitl) {
+export function createTools(store, router, hitl, pipe = null) {
   /** 도구 핸들러 래퍼 — 에러 처리 + MCP content 형식 변환 */
   function wrap(code, fn) {
     return async (args) => {
@@ -49,7 +59,7 @@ export function createTools(store, router, hitl) {
         },
       },
       handler: wrap('REGISTER_FAILED', (args) => {
-        const data = store.registerAgent(args);
+        const data = router.registerAgent(args);
         return { ok: true, data };
       }),
     },
@@ -124,7 +134,7 @@ export function createTools(store, router, hitl) {
     // ── 5. poll_messages ──
     {
       name: 'poll_messages',
-      description: '에이전트 수신함에서 대기 메시지를 가져옵니다. ack_ids로 이전 메시지 확인 가능',
+      description: 'Deprecated. poll_messages 대신 Named Pipe subscribe/publish 채널을 사용합니다',
       inputSchema: {
         type: 'object',
         required: ['agent_id'],
@@ -137,41 +147,29 @@ export function createTools(store, router, hitl) {
           auto_ack:       { type: 'boolean', default: false },
         },
       },
-      handler: wrap('POLL_FAILED', async (args) => {
-        // ACK 먼저 처리
-        const ackedIds = [];
-        if (args.ack_ids?.length) {
-          store.ackMessages(args.ack_ids, args.agent_id);
-          ackedIds.push(...args.ack_ids);
-        }
-
-        // 1차 폴링
-        let messages = store.pollForAgent(args.agent_id, {
+      handler: wrap('POLL_DEPRECATED', async (args) => {
+        const replay = router.drainAgent(args.agent_id, {
           max_messages: args.max_messages,
           include_topics: args.include_topics,
           auto_ack: args.auto_ack,
         });
-
-        // wait_ms > 0 이고 메시지 없으면 짧은 간격으로 반복 재시도
-        if (!messages.length && args.wait_ms > 0) {
-          const interval = Math.min(args.wait_ms, 500);
-          const deadline = Date.now() + Math.min(args.wait_ms, 30000);
-          while (!messages.length && Date.now() < deadline) {
-            await new Promise(r => setTimeout(r, interval));
-            messages = store.pollForAgent(args.agent_id, {
-              max_messages: args.max_messages,
-              include_topics: args.include_topics,
-              auto_ack: args.auto_ack,
-            });
-          }
+        if (args.ack_ids?.length) {
+          router.ackMessages(args.ack_ids, args.agent_id);
         }
-
         return {
-          ok: true,
+          ok: false,
+          error: {
+            code: 'POLL_DEPRECATED',
+            message: 'poll_messages는 deprecated 되었습니다. pipe subscribe/publish 채널을 사용하세요.',
+          },
           data: {
-            messages,
-            acked_ids: ackedIds,
-            next_poll_after_ms: messages.length ? 0 : 1000,
+            pipe_path: pipe?.path || null,
+            delivery_mode: 'pipe_push',
+            protocol: 'ndjson',
+            replay: {
+              messages: replay,
+              count: replay.length,
+            },
             server_time_ms: Date.now(),
           },
         };
@@ -336,5 +334,81 @@ export function createTools(store, router, hitl) {
         return teamSendMessage(args);
       }),
     },
+
+    // ── 13. pipeline_state ──
+    {
+      name: 'pipeline_state',
+      description: '파이프라인 상태를 조회합니다 (--thorough 모드)',
+      inputSchema: {
+        type: 'object',
+        required: ['team_name'],
+        properties: {
+          team_name: { type: 'string', pattern: '^[a-z0-9][a-z0-9-]*$' },
+        },
+      },
+      handler: wrap('PIPELINE_STATE_FAILED', (args) => {
+        ensurePipelineTable(store.db);
+        const state = readPipelineState(store.db, args.team_name);
+        return state
+          ? { ok: true, data: state }
+          : { ok: false, error: { code: 'PIPELINE_NOT_FOUND', message: `파이프라인 없음: ${args.team_name}` } };
+      }),
+    },
+
+    // ── 14. pipeline_advance ──
+    {
+      name: 'pipeline_advance',
+      description: '파이프라인을 다음 단계로 전이합니다 (전이 규칙 + fix loop 바운딩 적용)',
+      inputSchema: {
+        type: 'object',
+        required: ['team_name', 'phase'],
+        properties: {
+          team_name: { type: 'string', pattern: '^[a-z0-9][a-z0-9-]*$' },
+          phase: { type: 'string', enum: ['plan', 'prd', 'exec', 'verify', 'fix', 'complete', 'failed'] },
+        },
+      },
+      handler: wrap('PIPELINE_ADVANCE_FAILED', (args) => {
+        ensurePipelineTable(store.db);
+        const pipeline = createPipeline(store.db, args.team_name);
+        return pipeline.advance(args.phase);
+      }),
+    },
+
+    // ── 15. pipeline_init ──
+    {
+      name: 'pipeline_init',
+      description: '새 파이프라인을 초기화합니다 (기존 상태 덮어쓰기)',
+      inputSchema: {
+        type: 'object',
+        required: ['team_name'],
+        properties: {
+          team_name: { type: 'string', pattern: '^[a-z0-9][a-z0-9-]*$' },
+          fix_max: { type: 'integer', minimum: 1, maximum: 20, default: 3 },
+          ralph_max: { type: 'integer', minimum: 1, maximum: 100, default: 10 },
+        },
+      },
+      handler: wrap('PIPELINE_INIT_FAILED', (args) => {
+        ensurePipelineTable(store.db);
+        const state = initPipelineState(store.db, args.team_name, {
+          fix_max: args.fix_max,
+          ralph_max: args.ralph_max,
+        });
+        return { ok: true, data: state };
+      }),
+    },
+
+    // ── 16. pipeline_list ──
+    {
+      name: 'pipeline_list',
+      description: '활성 파이프라인 목록을 조회합니다',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+      },
+      handler: wrap('PIPELINE_LIST_FAILED', () => {
+        ensurePipelineTable(store.db);
+        return { ok: true, data: listPipelineStates(store.db) };
+      }),
+    },
   ];
 }