@triflux/core 10.50.2 → 10.52.0

package/hub/team/nativeProxy.mjs

@@ -0,0 +1,759 @@
+// hub/team/nativeProxy.mjs
+// Claude Native Teams 파일을 Hub tool/REST에서 안전하게 읽고 쓰기 위한 유틸.
+
+import { randomUUID } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  renameSync,
+  rmSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import {
+  open as openFile,
+  readdir,
+  readFile,
+  stat,
+  unlink as unlinkFile,
+} from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { isPidAlive } from "../lib/process-utils.mjs";
+import { IS_WINDOWS } from "../platform.mjs";
+
+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");
+const LOCK_STALE_MS = 30000;
+
+// ── 인메모리 캐시 (디렉토리 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 } };
+}
+
+function validateTeamName(teamName) {
+  if (!TEAM_NAME_RE.test(String(teamName || ""))) {
+    throw new Error("INVALID_TEAM_NAME");
+  }
+}
+
+async function readJsonSafe(path) {
+  try {
+    return JSON.parse(await readFile(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 (IS_WINDOWS && (e.code === "EPERM" || e.code === "EEXIST")) {
+      try {
+        unlinkSync(path);
+      } catch {}
+      renameSync(tmp, path);
+    } else {
+      try {
+        unlinkSync(tmp);
+      } catch {}
+      throw e;
+    }
+  }
+}
+
+async function sleepMs(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+async function readLockInfo(lockPath) {
+  let lockStat;
+  try {
+    lockStat = await stat(lockPath);
+  } catch {
+    return null;
+  }
+
+  let parsed = null;
+  try {
+    parsed = JSON.parse(await readFile(lockPath, "utf8"));
+  } catch {}
+
+  const now = Date.now();
+  const createdAtMs = Number(
+    parsed?.created_at_ms ??
+      parsed?.timestamp_ms ??
+      parsed?.timestamp ??
+      lockStat.mtimeMs,
+  );
+  const pid = Number(parsed?.pid);
+
+  return {
+    token: typeof parsed?.token === "string" ? parsed.token : null,
+    pid: Number.isInteger(pid) && pid > 0 ? pid : null,
+    created_at_ms: Number.isFinite(createdAtMs)
+      ? createdAtMs
+      : lockStat.mtimeMs,
+    mtime_ms: lockStat.mtimeMs,
+    age_ms: Math.max(
+      0,
+      now - (Number.isFinite(createdAtMs) ? createdAtMs : lockStat.mtimeMs),
+    ),
+  };
+}
+
+async function releaseFileLock(lockPath, token, handle) {
+  try {
+    await handle?.close();
+  } catch {}
+
+  try {
+    const current = await readLockInfo(lockPath);
+    if (!current || current.token === token) {
+      await unlinkFile(lockPath);
+    }
+  } catch {}
+}
+
+async function withFileLock(
+  lockPath,
+  fn,
+  retries = 20,
+  delayMs = 25,
+  staleMs = LOCK_STALE_MS,
+) {
+  mkdirSync(dirname(lockPath), { recursive: true });
+  const lockOwner = {
+    pid: process.pid,
+    token: randomUUID(),
+    created_at: new Date().toISOString(),
+    created_at_ms: Date.now(),
+  };
+  let handle = null;
+  let lastError = null;
+
+  for (let i = 0; i < retries; i += 1) {
+    try {
+      handle = await openFile(lockPath, "wx");
+      try {
+        await handle.writeFile(`${JSON.stringify(lockOwner)}\n`, "utf8");
+      } catch (writeError) {
+        await releaseFileLock(lockPath, lockOwner.token, handle);
+        throw writeError;
+      }
+      break;
+    } catch (e) {
+      lastError = e;
+      if (e?.code !== "EEXIST") throw e;
+
+      const current = await readLockInfo(lockPath);
+      const staleByAge = !current || current.age_ms > staleMs;
+      const staleByDeadPid = current?.pid != null && !isPidAlive(current.pid);
+      if (staleByAge || staleByDeadPid) {
+        try {
+          await unlinkFile(lockPath);
+          continue;
+        } catch (unlinkError) {
+          if (unlinkError?.code === "ENOENT") continue;
+          lastError = unlinkError;
+        }
+      }
+
+      if (i === retries - 1) throw e;
+      await sleepMs(delayMs);
+    }
+  }
+
+  if (!handle) {
+    throw lastError || new Error(`LOCK_NOT_ACQUIRED: ${lockPath}`);
+  }
+
+  try {
+    return await fn();
+  } finally {
+    await releaseFileLock(lockPath, lockOwner.token, handle);
+  }
+}
+
+function getLeadSessionId(config) {
+  return (
+    config?.leadSessionId ||
+    config?.lead_session_id ||
+    config?.lead?.lead_session_id ||
+    config?.lead?.sessionId ||
+    null
+  );
+}
+
+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 = await 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,
+  };
+}
+
+export async function forceCleanupTeam(teamName) {
+  validateTeamName(teamName);
+
+  let paths;
+  try {
+    paths = await resolveTeamPaths(teamName);
+  } catch {
+    paths = {
+      team_dir: join(TEAMS_ROOT, teamName),
+      config_path: join(TEAMS_ROOT, teamName, "config.json"),
+      tasks_dir: join(TASKS_ROOT, teamName),
+      lead_session_id: null,
+      config: null,
+    };
+  }
+
+  try {
+    const config = paths.config || (await readJsonSafe(paths.config_path));
+    if (config && Array.isArray(config.members)) {
+      atomicWriteJson(paths.config_path, {
+        ...config,
+        members: config.members.map((member) => ({
+          ...member,
+          isActive: false,
+        })),
+      });
+    }
+  } catch {}
+
+  const cleanupTargets = new Set([
+    paths.team_dir,
+    join(TASKS_ROOT, teamName),
+    paths.tasks_dir,
+  ]);
+  if (paths.lead_session_id) {
+    cleanupTargets.add(join(TASKS_ROOT, paths.lead_session_id));
+  }
+
+  for (const targetPath of cleanupTargets) {
+    if (!targetPath) continue;
+    try {
+      rmSync(targetPath, { recursive: true, force: true });
+    } catch {}
+  }
+}
+
+async function collectTaskFiles(tasksDir) {
+  if (!existsSync(tasksDir)) return [];
+
+  // 디렉토리 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;
+}
+
+async function readTaskFileCached(file) {
+  let fileMtime;
+  try {
+    fileMtime = (await stat(file)).mtimeMs;
+  } catch {
+    return { file, mtimeMs: null, json: null };
+  }
+
+  const contentCached = _taskContentCache.get(file);
+  if (contentCached && contentCached.mtimeMs === fileMtime) {
+    return { file, mtimeMs: fileMtime, json: contentCached.data };
+  }
+
+  const json = await readJsonSafe(file);
+  if (json && isObject(json)) {
+    _taskContentCache.set(file, { mtimeMs: fileMtime, data: json });
+  }
+
+  return { file, mtimeMs: fileMtime, json };
+}
+
+async 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 = await collectTaskFiles(tasksDir);
+  for (const file of files) {
+    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;
+}
+
+function isObject(v) {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+
+export async 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 = await 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 async 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 = await 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 files = await collectTaskFiles(paths.tasks_dir);
+  const records = await Promise.all(
+    files.map((file) => readTaskFileCached(file)),
+  );
+
+  const tasks = [];
+  for (const { file, mtimeMs: fileMtime, json } of records) {
+    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;
+
+    tasks.push({
+      ...json,
+      task_file: file,
+      mtime_ms: fileMtime,
+    });
+  }
+
+  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 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,
+    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 = await resolveTeamPaths(team_name);
+  if (paths.tasks_dir_resolution === "not_found") {
+    return err(
+      "TASKS_DIR_NOT_FOUND",
+      `task 디렉토리를 찾지 못했습니다: ${team_name}`,
+    );
+  }
+
+  const taskFile = await locateTaskFile(paths.tasks_dir, String(task_id));
+  if (!taskFile) {
+    return err("TASK_NOT_FOUND", `task를 찾지 못했습니다: ${task_id}`);
+  }
+
+  const lockFile = `${taskFile}.lock`;
+
+  try {
+    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 = (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가 일치하지 않습니다", {
+          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));
+        // 콘텐츠 캐시 무효화
+        _taskContentCache.delete(taskFile);
+      }
+
+      let afterMtime = beforeMtime;
+      try {
+        afterMtime = (await stat(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 async 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 = 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 = 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);
+  }
+}
+
+export const nativeProxy = Object.freeze({
+  teamInfo,
+  teamTaskList,
+  teamTaskUpdate,
+  teamSendMessage,
+});