triflux 3.2.0-dev.1 → 3.2.0-dev.11

package/hub/team/nativeProxy.mjs

@@ -0,0 +1,534 @@
+// hub/team/nativeProxy.mjs
+// Claude Native Teams 파일을 Hub tool/REST에서 안전하게 읽고 쓰기 위한 유틸.
+
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+  openSync,
+  closeSync,
+} from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+const TEAM_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+const CLAUDE_HOME = join(homedir(), '.claude');
+const TEAMS_ROOT = join(CLAUDE_HOME, 'teams');
+const TASKS_ROOT = join(CLAUDE_HOME, 'tasks');
+
+// ── 인메모리 캐시 (디렉토리 mtime 기반 무효화) ──
+const _dirCache = new Map(); // tasksDir → { mtimeMs, files: string[] }
+const _taskIdIndex = new Map(); // taskId → filePath
+
+function _invalidateCache(tasksDir) {
+  _dirCache.delete(tasksDir);
+}
+
+function err(code, message, extra = {}) {
+  return { ok: false, error: { code, message, ...extra } };
+}
+
+function validateTeamName(teamName) {
+  if (!TEAM_NAME_RE.test(String(teamName || ''))) {
+    throw new Error('INVALID_TEAM_NAME');
+  }
+}
+
+function readJsonSafe(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function atomicWriteJson(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+  writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+  try {
+    renameSync(tmp, path);
+  } catch (e) {
+    // Windows NTFS: 대상 파일 존재 시 rename 실패 가능 → 삭제 후 재시도
+    if (process.platform === 'win32' && (e.code === 'EPERM' || e.code === 'EEXIST')) {
+      try { unlinkSync(path); } catch {}
+      renameSync(tmp, path);
+    } else {
+      try { unlinkSync(tmp); } catch {}
+      throw e;
+    }
+  }
+}
+
+function sleepMs(ms) {
+  // busy-wait를 피하고 Atomics.wait로 동기 대기 (CPU 점유 최소화)
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function withFileLock(lockPath, fn, retries = 20, delayMs = 25) {
+  let fd = null;
+  for (let i = 0; i < retries; i += 1) {
+    try {
+      fd = openSync(lockPath, 'wx');
+      break;
+    } catch (e) {
+      if (e?.code !== 'EEXIST' || i === retries - 1) throw e;
+      sleepMs(delayMs);
+    }
+  }
+
+  try {
+    return fn();
+  } finally {
+    try { if (fd != null) closeSync(fd); } catch {}
+    try { unlinkSync(lockPath); } catch {}
+  }
+}
+
+function getLeadSessionId(config) {
+  return config?.leadSessionId
+    || config?.lead_session_id
+    || config?.lead?.lead_session_id
+    || config?.lead?.sessionId
+    || null;
+}
+
+export function resolveTeamPaths(teamName) {
+  validateTeamName(teamName);
+
+  const teamDir = join(TEAMS_ROOT, teamName);
+  const configPath = join(teamDir, 'config.json');
+  const inboxesDir = join(teamDir, 'inboxes');
+  const config = readJsonSafe(configPath);
+  const leadSessionId = getLeadSessionId(config);
+
+  const byTeam = join(TASKS_ROOT, teamName);
+  const byLeadSession = leadSessionId ? join(TASKS_ROOT, leadSessionId) : null;
+
+  let tasksDir = byTeam;
+  let tasksDirResolution = 'not_found';
+  if (existsSync(byTeam)) {
+    tasksDirResolution = 'team_name';
+  } else if (byLeadSession && existsSync(byLeadSession)) {
+    tasksDir = byLeadSession;
+    tasksDirResolution = 'lead_session_id';
+  }
+
+  return {
+    team_dir: teamDir,
+    config_path: configPath,
+    inboxes_dir: inboxesDir,
+    tasks_dir: tasksDir,
+    tasks_dir_resolution: tasksDirResolution,
+    lead_session_id: leadSessionId,
+    config,
+  };
+}
+
+function collectTaskFiles(tasksDir) {
+  if (!existsSync(tasksDir)) return [];
+
+  // 디렉토리 mtime 기반 캐시 — O(N) I/O를 반복 호출 시 O(1)로 축소
+  let dirMtime;
+  try { dirMtime = statSync(tasksDir).mtimeMs; } catch { return []; }
+
+  const cached = _dirCache.get(tasksDir);
+  if (cached && cached.mtimeMs === dirMtime) {
+    return cached.files;
+  }
+
+  const files = readdirSync(tasksDir)
+    .filter((name) => name.endsWith('.json'))
+    .filter((name) => !name.endsWith('.lock'))
+    .filter((name) => name !== '.highwatermark')
+    .map((name) => join(tasksDir, name));
+
+  _dirCache.set(tasksDir, { mtimeMs: dirMtime, files });
+  return files;
+}
+
+function locateTaskFile(tasksDir, taskId) {
+  const direct = join(tasksDir, `${taskId}.json`);
+  if (existsSync(direct)) return direct;
+
+  // ID→파일 인덱스 캐시
+  const indexed = _taskIdIndex.get(taskId);
+  if (indexed && existsSync(indexed)) return indexed;
+
+  // 캐시된 collectTaskFiles로 풀 스캔
+  const files = collectTaskFiles(tasksDir);
+  for (const file of files) {
+    if (basename(file, '.json') === taskId) {
+      _taskIdIndex.set(taskId, file);
+      return file;
+    }
+    const json = readJsonSafe(file);
+    if (json && String(json.id || '') === taskId) {
+      _taskIdIndex.set(taskId, file);
+      return file;
+    }
+  }
+  return null;
+}
+
+function isObject(v) {
+  return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+
+export function teamInfo(args = {}) {
+  const { team_name, include_members = true, include_paths = true } = args;
+  try {
+    validateTeamName(team_name);
+  } catch {
+    return err('INVALID_TEAM_NAME', 'team_name 형식이 올바르지 않습니다');
+  }
+
+  const paths = resolveTeamPaths(team_name);
+  if (!existsSync(paths.team_dir)) {
+    return err('TEAM_NOT_FOUND', `팀 디렉토리가 없습니다: ${paths.team_dir}`);
+  }
+
+  const members = Array.isArray(paths.config?.members) ? paths.config.members : [];
+  const leadAgentId = paths.config?.leadAgentId
+    || paths.config?.lead_agent_id
+    || members[0]?.agentId
+    || null;
+
+  return {
+    ok: true,
+    data: {
+      team: {
+        team_name,
+        description: paths.config?.description || null,
+      },
+      lead: {
+        lead_agent_id: leadAgentId,
+        lead_session_id: paths.lead_session_id,
+      },
+      ...(include_members ? { members } : {}),
+      ...(include_paths ? {
+        paths: {
+          config_path: paths.config_path,
+          tasks_dir: paths.tasks_dir,
+          inboxes_dir: paths.inboxes_dir,
+          tasks_dir_resolution: paths.tasks_dir_resolution,
+        },
+      } : {}),
+    },
+  };
+}
+
+export function teamTaskList(args = {}) {
+  const {
+    team_name,
+    owner,
+    statuses = [],
+    include_internal = false,
+    limit = 200,
+  } = args;
+
+  try {
+    validateTeamName(team_name);
+  } catch {
+    return err('INVALID_TEAM_NAME', 'team_name 형식이 올바르지 않습니다');
+  }
+
+  const paths = resolveTeamPaths(team_name);
+  if (paths.tasks_dir_resolution === 'not_found') {
+    return err('TASKS_DIR_NOT_FOUND', `task 디렉토리를 찾지 못했습니다: ${team_name}`);
+  }
+
+  const statusSet = new Set((statuses || []).map((s) => String(s)));
+  const maxCount = Math.max(1, Math.min(Number(limit) || 200, 1000));
+  let parseWarnings = 0;
+
+  const tasks = [];
+  for (const file of collectTaskFiles(paths.tasks_dir)) {
+    const json = readJsonSafe(file);
+    if (!json || !isObject(json)) {
+      parseWarnings += 1;
+      continue;
+    }
+
+    if (!include_internal && json?.metadata?._internal === true) continue;
+    if (owner && String(json.owner || '') !== String(owner)) continue;
+    if (statusSet.size > 0 && !statusSet.has(String(json.status || ''))) continue;
+
+    let mtime = Date.now();
+    try { mtime = statSync(file).mtimeMs; } catch {}
+
+    tasks.push({
+      ...json,
+      task_file: file,
+      mtime_ms: mtime,
+    });
+  }
+
+  tasks.sort((a, b) => Number(b.mtime_ms || 0) - Number(a.mtime_ms || 0));
+  const sliced = tasks.slice(0, maxCount);
+
+  return {
+    ok: true,
+    data: {
+      tasks: sliced,
+      count: sliced.length,
+      parse_warnings: parseWarnings,
+      tasks_dir: paths.tasks_dir,
+      tasks_dir_resolution: paths.tasks_dir_resolution,
+    },
+  };
+}
+
+// status 화이트리스트 (Claude Code API 호환)
+const VALID_STATUSES = new Set(['pending', 'in_progress', 'completed', 'deleted']);
+
+export function teamTaskUpdate(args = {}) {
+  // "failed" → "completed" + metadata.result 자동 매핑
+  if (String(args.status || '') === 'failed') {
+    args = {
+      ...args,
+      status: 'completed',
+      metadata_patch: { ...(args.metadata_patch || {}), result: 'failed' },
+    };
+  } else if (args.status != null && !VALID_STATUSES.has(String(args.status))) {
+    return err('INVALID_STATUS', `유효하지 않은 status: ${args.status}. 허용: ${[...VALID_STATUSES].join(', ')}`);
+  }
+
+  const {
+    team_name,
+    task_id,
+    claim = false,
+    owner,
+    status,
+    subject,
+    description,
+    activeForm,
+    add_blocks = [],
+    add_blocked_by = [],
+    metadata_patch,
+    if_match_mtime_ms,
+    actor,
+  } = args;
+
+  try {
+    validateTeamName(team_name);
+  } catch {
+    return err('INVALID_TEAM_NAME', 'team_name 형식이 올바르지 않습니다');
+  }
+
+  if (!String(task_id || '').trim()) {
+    return err('INVALID_TASK_ID', 'task_id가 필요합니다');
+  }
+
+  const paths = resolveTeamPaths(team_name);
+  if (paths.tasks_dir_resolution === 'not_found') {
+    return err('TASKS_DIR_NOT_FOUND', `task 디렉토리를 찾지 못했습니다: ${team_name}`);
+  }
+
+  const taskFile = locateTaskFile(paths.tasks_dir, String(task_id));
+  if (!taskFile) {
+    return err('TASK_NOT_FOUND', `task를 찾지 못했습니다: ${task_id}`);
+  }
+
+  const lockFile = `${taskFile}.lock`;
+
+  try {
+    return withFileLock(lockFile, () => {
+      const before = readJsonSafe(taskFile);
+      if (!before || !isObject(before)) {
+        return err('INVALID_TASK_FILE', `task 파일 파싱 실패: ${taskFile}`);
+      }
+
+      let beforeMtime = Date.now();
+      try { beforeMtime = statSync(taskFile).mtimeMs; } catch {}
+
+      if (if_match_mtime_ms != null && Number(if_match_mtime_ms) !== Number(beforeMtime)) {
+        return err('MTIME_CONFLICT', 'if_match_mtime_ms가 일치하지 않습니다', {
+          task_file: taskFile,
+          mtime_ms: beforeMtime,
+        });
+      }
+
+      const after = JSON.parse(JSON.stringify(before));
+      let claimed = false;
+      let updated = false;
+
+      if (claim) {
+        const requestedOwner = String(owner || actor || '');
+        const ownerNow = String(before.owner || '');
+        const ownerCompatible = ownerNow === '' || requestedOwner === '' || ownerNow === requestedOwner;
+        const statusPending = String(before.status || '') === 'pending';
+
+        if (!statusPending || !ownerCompatible) {
+          return err('CLAIM_CONFLICT', 'task claim 충돌', {
+            task_before: before,
+            task_file: taskFile,
+            mtime_ms: beforeMtime,
+          });
+        }
+
+        if (requestedOwner) after.owner = requestedOwner;
+        after.status = status || 'in_progress';
+        claimed = true;
+        updated = true;
+      }
+
+      if (owner != null && String(after.owner || '') !== String(owner)) {
+        after.owner = owner;
+        updated = true;
+      }
+      if (status != null && String(after.status || '') !== String(status)) {
+        after.status = status;
+        updated = true;
+      }
+      if (subject != null && String(after.subject || '') !== String(subject)) {
+        after.subject = subject;
+        updated = true;
+      }
+      if (description != null && String(after.description || '') !== String(description)) {
+        after.description = description;
+        updated = true;
+      }
+      if (activeForm != null && String(after.activeForm || '') !== String(activeForm)) {
+        after.activeForm = activeForm;
+        updated = true;
+      }
+
+      if (Array.isArray(add_blocks) && add_blocks.length > 0) {
+        const current = Array.isArray(after.blocks) ? [...after.blocks] : [];
+        for (const item of add_blocks) {
+          if (!current.includes(item)) current.push(item);
+        }
+        after.blocks = current;
+        updated = true;
+      }
+
+      if (Array.isArray(add_blocked_by) && add_blocked_by.length > 0) {
+        const current = Array.isArray(after.blockedBy) ? [...after.blockedBy] : [];
+        for (const item of add_blocked_by) {
+          if (!current.includes(item)) current.push(item);
+        }
+        after.blockedBy = current;
+        updated = true;
+      }
+
+      if (isObject(metadata_patch)) {
+        const base = isObject(after.metadata) ? after.metadata : {};
+        after.metadata = { ...base, ...metadata_patch };
+        updated = true;
+      }
+
+      if (updated) {
+        atomicWriteJson(taskFile, after);
+        _invalidateCache(dirname(taskFile));
+      }
+
+      let afterMtime = beforeMtime;
+      try { afterMtime = statSync(taskFile).mtimeMs; } catch {}
+
+      return {
+        ok: true,
+        data: {
+          claimed,
+          updated,
+          task_before: before,
+          task_after: updated ? after : before,
+          task_file: taskFile,
+          mtime_ms: afterMtime,
+        },
+      };
+    });
+  } catch (e) {
+    return err('TASK_UPDATE_FAILED', e.message);
+  }
+}
+
+function sanitizeRecipientName(v) {
+  return String(v || 'team-lead').replace(/[\\/:*?"<>|]/g, '_');
+}
+
+export function teamSendMessage(args = {}) {
+  const {
+    team_name,
+    from,
+    to = 'team-lead',
+    text,
+    summary,
+    color = 'blue',
+  } = args;
+
+  try {
+    validateTeamName(team_name);
+  } catch {
+    return err('INVALID_TEAM_NAME', 'team_name 형식이 올바르지 않습니다');
+  }
+
+  if (!String(from || '').trim()) return err('INVALID_FROM', 'from이 필요합니다');
+  if (!String(text || '').trim()) return err('INVALID_TEXT', 'text가 필요합니다');
+
+  const paths = resolveTeamPaths(team_name);
+  if (!existsSync(paths.team_dir)) {
+    return err('TEAM_NOT_FOUND', `팀 디렉토리가 없습니다: ${paths.team_dir}`);
+  }
+
+  const recipient = sanitizeRecipientName(to);
+  const inboxFile = join(paths.inboxes_dir, `${recipient}.json`);
+  const lockFile = `${inboxFile}.lock`;
+  let message;
+
+  try {
+    const unreadCount = withFileLock(lockFile, () => {
+      const queue = readJsonSafe(inboxFile);
+      const list = Array.isArray(queue) ? queue : [];
+
+      message = {
+        id: randomUUID(),
+        from: String(from),
+        text: String(text),
+        ...(summary ? { summary: String(summary) } : {}),
+        timestamp: new Date().toISOString(),
+        color: String(color || 'blue'),
+        read: false,
+      };
+      list.push(message);
+
+      // inbox 정리: 최대 200개 유지, read + 1시간 경과 메시지 제거
+      const MAX_INBOX = 200;
+      if (list.length > MAX_INBOX) {
+        const ONE_HOUR_MS = 3600000;
+        const cutoff = Date.now() - ONE_HOUR_MS;
+        const pruned = list.filter((m) =>
+          m?.read !== true || !m?.timestamp || new Date(m.timestamp).getTime() > cutoff
+        );
+        list.length = 0;
+        list.push(...pruned);
+        if (list.length > MAX_INBOX) {
+          list.splice(0, list.length - MAX_INBOX);
+        }
+      }
+
+      atomicWriteJson(inboxFile, list);
+
+      return list.filter((m) => m?.read !== true).length;
+    });
+
+    return {
+      ok: true,
+      data: {
+        message_id: message.id,
+        recipient,
+        inbox_file: inboxFile,
+        queued_at: message.timestamp,
+        unread_count: unreadCount,
+      },
+    };
+  } catch (e) {
+    return err('SEND_MESSAGE_FAILED', e.message);
+  }
+}

package/hub/team/orchestrator.mjs

@@ -40,45 +40,76 @@ export function decomposeTask(taskDescription, agentCount) {
 }
 
 /**
- * 에이전트별 초기 프롬프트 생성
+ * 리드(보통 claude) 초기 프롬프트 생성
+ * @param {string} taskDescription
+ * @param {object} config
+ * @param {string} config.agentId
+ * @param {string} config.hubUrl
+ * @param {string} config.teammateMode
+ * @param {Array<{agentId:string, cli:string, subtask:string}>} config.workers
+ * @returns {string}
+ */
+export function buildLeadPrompt(taskDescription, config) {
+  const { agentId, hubUrl, teammateMode = "tmux", workers = [] } = config;
+
+  const roster = workers
+    .map((w, i) => `${i + 1}. ${w.agentId} (${w.cli}) — ${w.subtask}`)
+    .join("\n") || "- (워커 없음)";
+
+  const workerIds = workers.map((w) => w.agentId).join(", ");
+
+  const bridgePath = "node hub/bridge.mjs";
+
+  return `리드 에이전트: ${agentId}
+
+목표: ${taskDescription}
+모드: ${teammateMode}
+
+워커:
+${roster}
+
+규칙:
+- 가능한 짧고 핵심만 지시/요약(토큰 절약)
+- 워커 제어:
+  ${bridgePath} result --agent ${agentId} --topic lead.control
+- 워커 결과 수집:
+  ${bridgePath} context --agent ${agentId} --max 20
+- 최종 결과는 topic="task.result"를 모아 통합
+
+워커 ID: ${workerIds || "(없음)"}
+지금 즉시 워커를 배정하고 병렬 진행을 관리하라.`;
+}
+
+/**
+ * 워커 초기 프롬프트 생성
  * @param {string} subtask — 이 에이전트의 서브태스크
  * @param {object} config
  * @param {string} config.cli — codex/gemini/claude
  * @param {string} config.agentId — 에이전트 식별자
  * @param {string} config.hubUrl — Hub URL
- * @param {string} config.sessionName — tmux 세션 이름
  * @returns {string}
  */
 export function buildPrompt(subtask, config) {
   const { cli, agentId, hubUrl } = config;
 
-  // Hub MCP 도구 사용 안내 (CLI별 차이 없이 공통)
-  const hubInstructions = `
-[Hub 메시지 도구]
-tfx-hub MCP 서버(${hubUrl})가 연결되어 있다면 아래 도구를 사용할 수 있다:
-- register: 에이전트 등록 (agent_id: "${agentId}", cli: "${cli}")
-- publish: 결과 발행 (topic: "task.result")
-- poll_messages: 다른 에이전트 메시지 수신
-- ask: 다른 에이전트에게 질문
+  const hubBase = hubUrl.replace("/mcp", "");
 
-MCP 도구가 없으면 REST API 사용:
-  curl -s -X POST ${hubUrl.replace("/mcp", "")}/bridge/register -H 'Content-Type: application/json' -d '{"agent_id":"${agentId}","cli":"${cli}","timeout_sec":600}'
-  curl -s -X POST ${hubUrl.replace("/mcp", "")}/bridge/result -H 'Content-Type: application/json' -d '{"agent_id":"${agentId}","topic":"task.result","payload":{"summary":"결과 요약"}}'
-`.trim();
+  const bridgePath = "node hub/bridge.mjs";
 
-  return `너는 tfx-hub 팀의 에이전트 ${agentId}이다.
+  return `워커: ${agentId} (${cli})
+작업: ${subtask}
 
-[작업]
-${subtask}
+필수 규칙:
+1) 간결하게 작업(불필요한 장문 설명 금지)
+2) 시작 즉시 등록:
+   ${bridgePath} register --agent ${agentId} --cli ${cli} --topics lead.control,task.result
+3) 주기적으로 수신함 확인:
+   ${bridgePath} context --agent ${agentId} --max 10
+4) lead.control 수신 시 즉시 반응 (interrupt/stop/pause/resume)
+5) 완료 시 결과 발행:
+   ${bridgePath} result --agent ${agentId} --topic task.result --file <출력파일>
 
-[규칙]
-- 작업 완료 후 반드시 결과를 Hub에 발행하라
-- 에이전트 ID: ${agentId}
-- 다른 에이전트 결과가 필요하면 poll_messages로 확인
-
-${hubInstructions}
-
-작업을 시작하라.`;
+지금 작업을 시작하라.`;
 }
 
 /**
@@ -87,16 +118,44 @@ ${hubInstructions}
  * @param {Array<{target: string, cli: string, subtask: string}>} assignments
  * @param {object} opts
  * @param {string} opts.hubUrl — Hub URL
+ * @param {{target:string, cli:string, task:string}|null} opts.lead
+ * @param {string} opts.teammateMode
  * @returns {Promise<void>}
  */
 export async function orchestrate(sessionName, assignments, opts = {}) {
-  const { hubUrl = "http://127.0.0.1:27888/mcp" } = opts;
+  const {
+    hubUrl = "http://127.0.0.1:27888/mcp",
+    lead = null,
+    teammateMode = "tmux",
+  } = opts;
+
+  const workers = assignments.map(({ target, cli, subtask }) => ({
+    target,
+    cli,
+    subtask,
+    agentId: `${cli}-${target.split(".").pop()}`,
+  }));
+
+  if (lead?.target) {
+    const leadAgentId = `${lead.cli || "claude"}-${lead.target.split(".").pop()}`;
+    const leadPrompt = buildLeadPrompt(lead.task || "팀 작업 조율", {
+      agentId: leadAgentId,
+      hubUrl,
+      teammateMode,
+      workers: workers.map((w) => ({ agentId: w.agentId, cli: w.cli, subtask: w.subtask })),
+    });
+    injectPrompt(lead.target, leadPrompt, { useFileRef: true });
+    await new Promise((r) => setTimeout(r, 100));
+  }
 
-  for (const { target, cli, subtask } of assignments) {
-    const agentId = `${cli}-${target.split(".").pop()}`;
-    const prompt = buildPrompt(subtask, { cli, agentId, hubUrl, sessionName });
-    injectPrompt(target, prompt);
-    // pane 간 100ms 간격 (안정성)
+  for (const worker of workers) {
+    const prompt = buildPrompt(worker.subtask, {
+      cli: worker.cli,
+      agentId: worker.agentId,
+      hubUrl,
+      sessionName,
+    });
+    injectPrompt(worker.target, prompt, { useFileRef: true });
     await new Promise((r) => setTimeout(r, 100));
   }
 }