triflux 3.2.0-dev.1 → 3.2.0-dev.2

package/hub/team/nativeProxy.mjs

@@ -0,0 +1,455 @@
+// 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');
+
+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');
+  renameSync(tmp, path);
+}
+
+function sleepMs(ms) {
+  const end = Date.now() + ms;
+  while (Date.now() < end) {}
+}
+
+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 [];
+  return readdirSync(tasksDir)
+    .filter((name) => name.endsWith('.json'))
+    .filter((name) => !name.endsWith('.lock'))
+    .filter((name) => name !== '.highwatermark')
+    .map((name) => join(tasksDir, name));
+}
+
+function locateTaskFile(tasksDir, taskId) {
+  const direct = join(tasksDir, `${taskId}.json`);
+  if (existsSync(direct)) return direct;
+
+  const files = collectTaskFiles(tasksDir);
+  for (const file of files) {
+    if (basename(file, '.json') === taskId) return file;
+    const json = readJsonSafe(file);
+    if (json && String(json.id || '') === taskId) 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,
+    },
+  };
+}
+
+export function teamTaskUpdate(args = {}) {
+  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);
+      }
+
+      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 queue = readJsonSafe(inboxFile);
+  const list = Array.isArray(queue) ? queue : [];
+
+  const 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);
+
+  try {
+    atomicWriteJson(inboxFile, list);
+  } catch (e) {
+    return err('SEND_MESSAGE_FAILED', e.message);
+  }
+
+  const unreadCount = 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,
+    },
+  };
+}

package/hub/team/orchestrator.mjs

@@ -40,45 +40,81 @@ export function decomposeTask(taskDescription, agentCount) {
 }
 
 /**
- * 에이전트별 초기 프롬프트 생성
- * @param {string} subtask — 이 에이전트의 서브태스크
+ * 리드(보통 claude) 초기 프롬프트 생성
+ * @param {string} taskDescription
  * @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 세션 이름
+ * @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 buildPrompt(subtask, config) {
-  const { cli, agentId, hubUrl } = config;
+export function buildLeadPrompt(taskDescription, config) {
+  const { agentId, hubUrl, teammateMode = "tmux", workers = [] } = 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 roster = workers
+    .map((w, i) => `${i + 1}. ${w.agentId} (${w.cli}) — ${w.subtask}`)
+    .join("\n") || "- (워커 없음)";
 
-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 workerIds = workers.map((w) => w.agentId).join(", ");
 
-  return `너는 tfx-hub 팀의 에이전트 ${agentId}이다.
+  return `리드 에이전트: ${agentId}
 
-[작업]
-${subtask}
+목표: ${taskDescription}
+모드: ${teammateMode}
 
-[규칙]
-- 작업 완료 후 반드시 결과를 Hub에 발행하라
-- 에이전트 ID: ${agentId}
-- 다른 에이전트 결과가 필요하면 poll_messages로 확인
+워커:
+${roster}
 
-${hubInstructions}
+규칙:
+- 가능한 짧고 핵심만 지시/요약(토큰 절약)
+- 워커 제어 메시지 표준:
+  publish(from="${agentId}", to="<worker-agent-id>", topic="lead.control", payload={command:"interrupt|stop|pause|resume", reason:"..."})
+- 워커 결과 수집:
+  poll_messages(agent_id="${agentId}", wait_ms=1000, max_messages=20)
+- 최종 결과는 topic="task.result"를 모아 통합
 
-작업을 시작하라.`;
+권장 워커 ID: ${workerIds || "(없음)"}
+Hub: ${hubUrl}
+지금 즉시 워커를 배정하고 병렬 진행을 관리하라.`;
+}
+
+/**
+ * 워커 초기 프롬프트 생성
+ * @param {string} subtask — 이 에이전트의 서브태스크
+ * @param {object} config
+ * @param {string} config.cli — codex/gemini/claude
+ * @param {string} config.agentId — 에이전트 식별자
+ * @param {string} config.hubUrl — Hub URL
+ * @returns {string}
+ */
+export function buildPrompt(subtask, config) {
+  const { cli, agentId, hubUrl } = config;
+
+  const hubBase = hubUrl.replace("/mcp", "");
+
+  return `워커: ${agentId} (${cli})
+작업: ${subtask}
+
+필수 규칙:
+1) 간결하게 작업(불필요한 장문 설명 금지)
+2) 시작 즉시 register 실행:
+   register(agent_id="${agentId}", cli="${cli}", capabilities=["code"], topics=["lead.control","task.result"], heartbeat_ttl_ms=600000)
+3) 주기적으로 수신함 확인:
+   poll_messages(agent_id="${agentId}", wait_ms=1000, max_messages=10)
+4) lead.control 수신 시 즉시 반응
+   - interrupt: 즉시 중단, 진행상태 요약 publish
+   - stop: 작업 종료, 최종 요약 publish 후 대기
+   - pause: 작업 일시정지
+   - resume: 작업 재개
+5) 완료 시 결과 발행:
+   publish(from="${agentId}", to="topic:task.result", topic="task.result", payload={summary:"..."})
+
+MCP가 없으면 REST 폴백:
+- POST ${hubBase}/bridge/register
+- POST ${hubBase}/bridge/result
+
+지금 작업을 시작하라.`;
 }
 
 /**
@@ -87,16 +123,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);
+    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);
     await new Promise((r) => setTimeout(r, 100));
   }
 }

package/hub/team/pane.mjs

@@ -1,30 +1,39 @@
 // hub/team/pane.mjs — pane별 CLI 실행 + stdin 주입
 // 의존성: child_process, fs, os, path (Node.js 내장)만 사용
-import { execSync } from "node:child_process";
 import { writeFileSync, unlinkSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { detectMultiplexer } from "./session.mjs";
+import { detectMultiplexer, tmuxExec } from "./session.mjs";
 
 /** Windows 경로를 MSYS2/Git Bash tmux용 POSIX 경로로 변환 */
 function toTmuxPath(p) {
   if (process.platform !== "win32") return p;
-  // C:\Users\... → /c/Users/...
-  return p.replace(/\\/g, "/").replace(/^([A-Za-z]):/, (_, d) => `/${d.toLowerCase()}`);
+
+  const normalized = p.replace(/\\/g, "/");
+  const m = normalized.match(/^([A-Za-z]):\/(.*)$/);
+  if (!m) return normalized;
+
+  const drive = m[1].toLowerCase();
+  const rest = m[2];
+  const mux = detectMultiplexer();
+
+  // wsl tmux는 /mnt/c/... 경로를 사용
+  if (mux === "wsl-tmux") {
+    return `/mnt/${drive}/${rest}`;
+  }
+
+  // Git Bash/MSYS tmux는 /c/... 경로를 사용
+  return `/${drive}/${rest}`;
 }
 
 /** tmux 커맨드 실행 (session.mjs와 동일 패턴) */
 function tmux(args, opts = {}) {
-  const mux = detectMultiplexer();
-  if (!mux) throw new Error("tmux 미발견");
-  const prefix = mux === "wsl-tmux" ? "wsl tmux" : "tmux";
-  const result = execSync(`${prefix} ${args}`, {
+  return tmuxExec(args, {
     encoding: "utf8",
     timeout: 10000,
     stdio: ["pipe", "pipe", "pipe"],
     ...opts,
   });
-  return result != null ? result.trim() : "";
 }
 
 /**