triflux 3.2.0-dev.1 → 3.2.0-dev.10

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

@@ -1,15 +1,23 @@
-// hub/tools.mjs — MCP 도구 8개 정의
-// register, status, publish, ask, poll_messages, handoff, request_human_input, submit_human_input
+// hub/tools.mjs — MCP 도구 정의
+// register/status/publish/ask/poll/handoff/HITL + team proxy
 // 모든 도구 응답: { ok: boolean, error?: { code, message }, data?: ... }
 
+import {
+  teamInfo,
+  teamTaskList,
+  teamTaskUpdate,
+  teamSendMessage,
+} from './team/nativeProxy.mjs';
+
 /**
  * MCP 도구 목록 생성
  * @param {object} store  — createStore() 반환
  * @param {object} router — createRouter() 반환
- * @param {object} hitl   — createHitlManager() 반환
- * @returns {Array<{name, description, inputSchema, handler}>}
- */
-export function createTools(store, router, hitl) {
+ * @param {object} hitl   — createHitlManager() 반환
+ * @param {object} pipe   — createPipeServer() 반환
+ * @returns {Array<{name, description, inputSchema, handler}>}
+ */
+export function createTools(store, router, hitl, pipe = null) {
   /** 도구 핸들러 래퍼 — 에러 처리 + MCP content 형식 변환 */
   function wrap(code, fn) {
     return async (args) => {
@@ -41,10 +49,10 @@ export function createTools(store, router, hitl) {
           heartbeat_ttl_ms: { type: 'integer', minimum: 10000, maximum: 7200000 },
         },
       },
-      handler: wrap('REGISTER_FAILED', (args) => {
-        const data = store.registerAgent(args);
-        return { ok: true, data };
-      }),
+      handler: wrap('REGISTER_FAILED', (args) => {
+        const data = router.registerAgent(args);
+        return { ok: true, data };
+      }),
     },
 
     // ── 2. status ──
@@ -114,10 +122,10 @@ export function createTools(store, router, hitl) {
       }),
     },
 
-    // ── 5. poll_messages ──
-    {
-      name: 'poll_messages',
-      description: '에이전트 수신함에서 대기 메시지를 가져옵니다. ack_ids로 이전 메시지 확인 가능',
+    // ── 5. poll_messages ──
+    {
+      name: 'poll_messages',
+      description: 'Deprecated. poll_messages 대신 Named Pipe subscribe/publish 채널을 사용합니다',
       inputSchema: {
         type: 'object',
         required: ['agent_id'],
@@ -129,46 +137,34 @@ export function createTools(store, router, hitl) {
           ack_ids:        { type: 'array', items: { type: 'string' }, maxItems: 100 },
           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, {
-          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,
-            });
-          }
+      },
+      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,
+        });
+        if (args.ack_ids?.length) {
+          router.ackMessages(args.ack_ids, args.agent_id);
         }
-
-        return {
-          ok: true,
-          data: {
-            messages,
-            acked_ids: ackedIds,
-            next_poll_after_ms: messages.length ? 0 : 1000,
-            server_time_ms: Date.now(),
-          },
-        };
-      }),
+        return {
+          ok: false,
+          error: {
+            code: 'POLL_DEPRECATED',
+            message: 'poll_messages는 deprecated 되었습니다. pipe subscribe/publish 채널을 사용하세요.',
+          },
+          data: {
+            pipe_path: pipe?.path || null,
+            delivery_mode: 'pipe_push',
+            protocol: 'ndjson',
+            replay: {
+              messages: replay,
+              count: replay.length,
+            },
+            server_time_ms: Date.now(),
+          },
+        };
+      }),
     },
 
     // ── 6. handoff ──
@@ -238,5 +234,96 @@ export function createTools(store, router, hitl) {
         return hitl.submitHumanInput(args);
       }),
     },
+
+    // ── 9. team_info ──
+    {
+      name: 'team_info',
+      description: 'Claude Native Teams 메타/멤버/경로 정보를 조회합니다',
+      inputSchema: {
+        type: 'object',
+        required: ['team_name'],
+        properties: {
+          team_name: { type: 'string', minLength: 1, maxLength: 128, pattern: '^[a-z0-9][a-z0-9-]*$' },
+          include_members: { type: 'boolean', default: true },
+          include_paths: { type: 'boolean', default: true },
+        },
+      },
+      handler: wrap('TEAM_INFO_FAILED', (args) => {
+        return teamInfo(args);
+      }),
+    },
+
+    // ── 10. team_task_list ──
+    {
+      name: 'team_task_list',
+      description: 'Claude Native Teams task 목록을 owner/status 조건으로 조회합니다',
+      inputSchema: {
+        type: 'object',
+        required: ['team_name'],
+        properties: {
+          team_name: { type: 'string', pattern: '^[a-z0-9][a-z0-9-]*$' },
+          owner: { type: 'string' },
+          statuses: {
+            type: 'array',
+            items: { type: 'string', enum: ['pending', 'in_progress', 'completed', 'failed', 'deleted'] },
+            maxItems: 8,
+          },
+          include_internal: { type: 'boolean', default: false },
+          limit: { type: 'integer', minimum: 1, maximum: 1000, default: 200 },
+        },
+      },
+      handler: wrap('TEAM_TASK_LIST_FAILED', (args) => {
+        return teamTaskList(args);
+      }),
+    },
+
+    // ── 11. team_task_update ──
+    {
+      name: 'team_task_update',
+      description: 'Claude Native Teams task를 claim/update 합니다',
+      inputSchema: {
+        type: 'object',
+        required: ['team_name', 'task_id'],
+        properties: {
+          team_name: { type: 'string', pattern: '^[a-z0-9][a-z0-9-]*$' },
+          task_id: { type: 'string', minLength: 1, maxLength: 64 },
+          claim: { type: 'boolean', default: false },
+          owner: { type: 'string' },
+          status: { type: 'string', enum: ['pending', 'in_progress', 'completed', 'failed', 'deleted'] },
+          subject: { type: 'string' },
+          description: { type: 'string' },
+          activeForm: { type: 'string' },
+          add_blocks: { type: 'array', items: { type: 'string' } },
+          add_blocked_by: { type: 'array', items: { type: 'string' } },
+          metadata_patch: { type: 'object' },
+          if_match_mtime_ms: { type: 'number' },
+          actor: { type: 'string' },
+        },
+      },
+      handler: wrap('TEAM_TASK_UPDATE_FAILED', (args) => {
+        return teamTaskUpdate(args);
+      }),
+    },
+
+    // ── 12. team_send_message ──
+    {
+      name: 'team_send_message',
+      description: 'Claude Native Teams inbox에 메시지를 append 합니다',
+      inputSchema: {
+        type: 'object',
+        required: ['team_name', 'from', 'text'],
+        properties: {
+          team_name: { type: 'string', pattern: '^[a-z0-9][a-z0-9-]*$' },
+          from: { type: 'string', minLength: 1, maxLength: 128 },
+          to: { type: 'string', default: 'team-lead' },
+          text: { type: 'string', minLength: 1, maxLength: 200000 },
+          summary: { type: 'string', maxLength: 1000 },
+          color: { type: 'string', default: 'blue' },
+        },
+      },
+      handler: wrap('TEAM_SEND_MESSAGE_FAILED', (args) => {
+        return teamSendMessage(args);
+      }),
+    },
   ];
 }