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

package/hub/team/nativeProxy.mjs

@@ -4,8 +4,6 @@
 import {
   existsSync,
   mkdirSync,
-  readdirSync,
-  readFileSync,
   renameSync,
   statSync,
   unlinkSync,
@@ -13,6 +11,7 @@ import {
   openSync,
   closeSync,
 } from 'node:fs';
+import { readdir, stat, readFile } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 import { randomUUID } from 'node:crypto';
@@ -22,6 +21,15 @@ 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
+const _taskContentCache = new Map(); // filePath → { mtimeMs, data }
+
+function _invalidateCache(tasksDir) {
+  _dirCache.delete(tasksDir);
+}
+
 function err(code, message, extra = {}) {
   return { ok: false, error: { code, message, ...extra } };
 }
@@ -32,9 +40,9 @@ function validateTeamName(teamName) {
   }
 }
 
-function readJsonSafe(path) {
+async function readJsonSafe(path) {
   try {
-    return JSON.parse(readFileSync(path, 'utf8'));
+    return JSON.parse(await readFile(path, 'utf8'));
   } catch {
     return null;
   }
@@ -44,15 +52,25 @@ 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);
+  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);
-}
+async function sleepMs(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
 
-function withFileLock(lockPath, fn, retries = 20, delayMs = 25) {
+async function withFileLock(lockPath, fn, retries = 20, delayMs = 25) {
   let fd = null;
   for (let i = 0; i < retries; i += 1) {
     try {
@@ -60,12 +78,12 @@ function withFileLock(lockPath, fn, retries = 20, delayMs = 25) {
       break;
     } catch (e) {
       if (e?.code !== 'EEXIST' || i === retries - 1) throw e;
-      sleepMs(delayMs);
+      await sleepMs(delayMs);
     }
   }
 
   try {
-    return fn();
+    return await fn();
   } finally {
     try { if (fd != null) closeSync(fd); } catch {}
     try { unlinkSync(lockPath); } catch {}
@@ -80,13 +98,13 @@ function getLeadSessionId(config) {
     || null;
 }
 
-export function resolveTeamPaths(teamName) {
+export async 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 config = await readJsonSafe(configPath);
   const leadSessionId = getLeadSessionId(config);
 
   const byTeam = join(TASKS_ROOT, teamName);
@@ -112,24 +130,49 @@ export function resolveTeamPaths(teamName) {
   };
 }
 
-function collectTaskFiles(tasksDir) {
+async function collectTaskFiles(tasksDir) {
   if (!existsSync(tasksDir)) return [];
-  return readdirSync(tasksDir)
+
+  // 디렉토리 mtime 기반 캐시 — O(N) I/O를 반복 호출 시 O(1)로 축소
+  let dirMtime;
+  try { dirMtime = (await stat(tasksDir)).mtimeMs; } catch { return []; }
+
+  const cached = _dirCache.get(tasksDir);
+  if (cached && cached.mtimeMs === dirMtime) {
+    return cached.files;
+  }
+
+  const entries = await readdir(tasksDir);
+  const files = entries
     .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) {
+async function locateTaskFile(tasksDir, taskId) {
   const direct = join(tasksDir, `${taskId}.json`);
   if (existsSync(direct)) return direct;
 
-  const files = collectTaskFiles(tasksDir);
+  // ID→파일 인덱스 캐시
+  const indexed = _taskIdIndex.get(taskId);
+  if (indexed && existsSync(indexed)) return indexed;
+
+  // 캐시된 collectTaskFiles로 풀 스캔
+  const files = await 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;
+    if (basename(file, '.json') === taskId) {
+      _taskIdIndex.set(taskId, file);
+      return file;
+    }
+    const json = await readJsonSafe(file);
+    if (json && String(json.id || '') === taskId) {
+      _taskIdIndex.set(taskId, file);
+      return file;
+    }
   }
   return null;
 }
@@ -138,7 +181,7 @@ function isObject(v) {
   return !!v && typeof v === 'object' && !Array.isArray(v);
 }
 
-export function teamInfo(args = {}) {
+export async function teamInfo(args = {}) {
   const { team_name, include_members = true, include_paths = true } = args;
   try {
     validateTeamName(team_name);
@@ -146,7 +189,7 @@ export function teamInfo(args = {}) {
     return err('INVALID_TEAM_NAME', 'team_name 형식이 올바르지 않습니다');
   }
 
-  const paths = resolveTeamPaths(team_name);
+  const paths = await resolveTeamPaths(team_name);
   if (!existsSync(paths.team_dir)) {
     return err('TEAM_NOT_FOUND', `팀 디렉토리가 없습니다: ${paths.team_dir}`);
   }
@@ -181,7 +224,7 @@ export function teamInfo(args = {}) {
   };
 }
 
-export function teamTaskList(args = {}) {
+export async function teamTaskList(args = {}) {
   const {
     team_name,
     owner,
@@ -196,7 +239,7 @@ export function teamTaskList(args = {}) {
     return err('INVALID_TEAM_NAME', 'team_name 형식이 올바르지 않습니다');
   }
 
-  const paths = resolveTeamPaths(team_name);
+  const paths = await resolveTeamPaths(team_name);
   if (paths.tasks_dir_resolution === 'not_found') {
     return err('TASKS_DIR_NOT_FOUND', `task 디렉토리를 찾지 못했습니다: ${team_name}`);
   }
@@ -206,8 +249,22 @@ export function teamTaskList(args = {}) {
   let parseWarnings = 0;
 
   const tasks = [];
-  for (const file of collectTaskFiles(paths.tasks_dir)) {
-    const json = readJsonSafe(file);
+  for (const file of await collectTaskFiles(paths.tasks_dir)) {
+    // mtime 기반 task 콘텐츠 캐시 — 변경 없으면 파일 읽기 생략
+    let fileMtime = Date.now();
+    try { fileMtime = (await stat(file)).mtimeMs; } catch {}
+
+    const contentCached = _taskContentCache.get(file);
+    let json;
+    if (contentCached && contentCached.mtimeMs === fileMtime) {
+      json = contentCached.data;
+    } else {
+      json = await readJsonSafe(file);
+      if (json && isObject(json)) {
+        _taskContentCache.set(file, { mtimeMs: fileMtime, data: json });
+      }
+    }
+
     if (!json || !isObject(json)) {
       parseWarnings += 1;
       continue;
@@ -217,13 +274,10 @@ export function teamTaskList(args = {}) {
     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,
+      mtime_ms: fileMtime,
     });
   }
 
@@ -242,7 +296,21 @@ export function teamTaskList(args = {}) {
   };
 }
 
-export function teamTaskUpdate(args = {}) {
+// status 화이트리스트 (Claude Code API 호환)
+const VALID_STATUSES = new Set(['pending', 'in_progress', 'completed', 'deleted']);
+
+export async 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,
@@ -269,12 +337,12 @@ export function teamTaskUpdate(args = {}) {
     return err('INVALID_TASK_ID', 'task_id가 필요합니다');
   }
 
-  const paths = resolveTeamPaths(team_name);
+  const paths = await 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));
+  const taskFile = await locateTaskFile(paths.tasks_dir, String(task_id));
   if (!taskFile) {
     return err('TASK_NOT_FOUND', `task를 찾지 못했습니다: ${task_id}`);
   }
@@ -282,14 +350,14 @@ export function teamTaskUpdate(args = {}) {
   const lockFile = `${taskFile}.lock`;
 
   try {
-    return withFileLock(lockFile, () => {
-      const before = readJsonSafe(taskFile);
+    return await withFileLock(lockFile, async () => {
+      const before = await readJsonSafe(taskFile);
       if (!before || !isObject(before)) {
         return err('INVALID_TASK_FILE', `task 파일 파싱 실패: ${taskFile}`);
       }
 
       let beforeMtime = Date.now();
-      try { beforeMtime = statSync(taskFile).mtimeMs; } catch {}
+      try { beforeMtime = (await stat(taskFile)).mtimeMs; } catch {}
 
       if (if_match_mtime_ms != null && Number(if_match_mtime_ms) !== Number(beforeMtime)) {
         return err('MTIME_CONFLICT', 'if_match_mtime_ms가 일치하지 않습니다', {
@@ -369,6 +437,9 @@ export function teamTaskUpdate(args = {}) {
 
       if (updated) {
         atomicWriteJson(taskFile, after);
+        _invalidateCache(dirname(taskFile));
+        // 콘텐츠 캐시 무효화
+        _taskContentCache.delete(taskFile);
       }
 
       let afterMtime = beforeMtime;
@@ -395,7 +466,7 @@ function sanitizeRecipientName(v) {
   return String(v || 'team-lead').replace(/[\\/:*?"<>|]/g, '_');
 }
 
-export function teamSendMessage(args = {}) {
+export async function teamSendMessage(args = {}) {
   const {
     team_name,
     from,
@@ -414,47 +485,63 @@ export function teamSendMessage(args = {}) {
   if (!String(from || '').trim()) return err('INVALID_FROM', 'from이 필요합니다');
   if (!String(text || '').trim()) return err('INVALID_TEXT', 'text가 필요합니다');
 
-  const paths = resolveTeamPaths(team_name);
+  const paths = await 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);
-      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);
-  }
-}
+  const recipient = sanitizeRecipientName(to);
+  const inboxFile = join(paths.inboxes_dir, `${recipient}.json`);
+  const lockFile = `${inboxFile}.lock`;
+  let message;
+
+  try {
+    const unreadCount = await withFileLock(lockFile, async () => {
+      const queue = await 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

@@ -58,6 +58,8 @@ export function buildLeadPrompt(taskDescription, config) {
 
   const workerIds = workers.map((w) => w.agentId).join(", ");
 
+  const bridgePath = "node hub/bridge.mjs";
+
   return `리드 에이전트: ${agentId}
 
 목표: ${taskDescription}
@@ -68,14 +70,13 @@ ${roster}
 
 규칙:
 - 가능한 짧고 핵심만 지시/요약(토큰 절약)
-- 워커 제어 메시지 표준:
-  publish(from="${agentId}", to="<worker-agent-id>", topic="lead.control", payload={command:"interrupt|stop|pause|resume", reason:"..."})
+- 워커 제어:
+  ${bridgePath} result --agent ${agentId} --topic lead.control
 - 워커 결과 수집:
-  poll_messages(agent_id="${agentId}", wait_ms=1000, max_messages=20)
+  ${bridgePath} context --agent ${agentId} --max 20
 - 최종 결과는 topic="task.result"를 모아 통합
 
-권장 워커 ID: ${workerIds || "(없음)"}
-Hub: ${hubUrl}
+워커 ID: ${workerIds || "(없음)"}
 지금 즉시 워커를 배정하고 병렬 진행을 관리하라.`;
 }
 
@@ -93,26 +94,20 @@ export function buildPrompt(subtask, config) {
 
   const hubBase = hubUrl.replace("/mcp", "");
 
+  const bridgePath = "node hub/bridge.mjs";
+
   return `워커: ${agentId} (${cli})
 작업: ${subtask}
 
 필수 규칙:
 1) 간결하게 작업(불필요한 장문 설명 금지)
-2) 시작 즉시 register 실행:
-   register(agent_id="${agentId}", cli="${cli}", capabilities=["code"], topics=["lead.control","task.result"], heartbeat_ttl_ms=600000)
+2) 시작 즉시 등록:
+   ${bridgePath} register --agent ${agentId} --cli ${cli} --topics lead.control,task.result
 3) 주기적으로 수신함 확인:
-   poll_messages(agent_id="${agentId}", wait_ms=1000, max_messages=10)
-4) lead.control 수신 시 즉시 반응
-   - interrupt: 즉시 중단, 진행상태 요약 publish
-   - stop: 작업 종료, 최종 요약 publish 후 대기
-   - pause: 작업 일시정지
-   - resume: 작업 재개
+   ${bridgePath} context --agent ${agentId} --max 10
+4) lead.control 수신 시 즉시 반응 (interrupt/stop/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
+   ${bridgePath} result --agent ${agentId} --topic task.result --file <출력파일>
 
 지금 작업을 시작하라.`;
 }
@@ -149,7 +144,7 @@ export async function orchestrate(sessionName, assignments, opts = {}) {
       teammateMode,
       workers: workers.map((w) => ({ agentId: w.agentId, cli: w.cli, subtask: w.subtask })),
     });
-    injectPrompt(lead.target, leadPrompt);
+    injectPrompt(lead.target, leadPrompt, { useFileRef: true });
     await new Promise((r) => setTimeout(r, 100));
   }
 
@@ -160,7 +155,7 @@ export async function orchestrate(sessionName, assignments, opts = {}) {
       hubUrl,
       sessionName,
     });
-    injectPrompt(worker.target, prompt);
+    injectPrompt(worker.target, prompt, { useFileRef: true });
     await new Promise((r) => setTimeout(r, 100));
   }
 }