@triflux/remote 10.53.0 → 10.55.0

package/hub/team/process-cleanup.mjs

@@ -1,386 +0,0 @@
-// hub/team/process-cleanup.mjs — 고아 node/python 프로세스 감지 및 정리
-// Windows: Get-CimInstance Win32_Process로 parent PID + cmdLine 접근
-// Unix: ps aux 파싱
-import { execFileSync, execFile as nodeExecFile } from "node:child_process";
-import { promisify } from "node:util";
-import { IS_WINDOWS } from "@triflux/core/hub/platform.mjs";
-
-const execFileAsync = promisify(nodeExecFile);
-
-// ── 상수 ────────────────────────────────────────────────────────────────────
-
-const TARGET_PROCESS_NAMES = ["node", "python", "python3"];
-const SIGTERM_GRACE_MS = 5000;
-
-export function forceKillPid(
-  pid,
-  {
-    isWindows = IS_WINDOWS,
-    execFileSyncFn = execFileSync,
-    killFn = process.kill,
-  } = {},
-) {
-  if (isWindows) {
-    try {
-      execFileSyncFn("taskkill", ["/F", "/T", "/PID", String(pid)], {
-        stdio: "ignore",
-        timeout: 5000,
-        windowsHide: true,
-      });
-      return;
-    } catch (taskkillError) {
-      try {
-        killFn(pid);
-        return;
-      } catch {
-        throw taskkillError;
-      }
-    }
-  }
-
-  killFn(pid, "SIGKILL");
-}
-
-// cmdLine 패턴 기반 화이트리스트 (고아 후보에서 제외)
-const WHITELIST_CMDLINE = [/oh-my-claudecode/i, /triflux[\\/]hub[\\/]s/i];
-
-// 프로세스명 기반 화이트리스트
-const WHITELIST_NAMES = ["claude", "CCXProcess"];
-
-// ── PowerShell / ps 파싱 ─────────────────────────────────────────────────────
-
-/**
- * Windows: Get-CimInstance Win32_Process로 프로세스 목록 조회
- * @param {Function} execFileFn - DI용 execFile 구현
- * @returns {Promise<Array<{pid,name,parentPid,cmdLine,ramMB}>>}
- */
-async function queryWindowsProcesses(execFileFn) {
-  const script = [
-    "Get-CimInstance Win32_Process |",
-    "  Select-Object ProcessId,Name,ParentProcessId,CommandLine,WorkingSetSize |",
-    "  ConvertTo-Json -Compress",
-  ].join(" ");
-
-  const { stdout } = await execFileFn(
-    "pwsh",
-    ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script],
-    { encoding: "utf8", timeout: 15_000, windowsHide: true },
-  );
-
-  const raw = JSON.parse(stdout.trim());
-  const items = Array.isArray(raw) ? raw : [raw];
-
-  return items.filter(Boolean).map((p) => ({
-    pid: Number(p.ProcessId),
-    name: String(p.Name || "").replace(/\.exe$/i, ""),
-    parentPid: Number(p.ParentProcessId) || 0,
-    cmdLine: String(p.CommandLine || ""),
-    ramMB: Math.round((Number(p.WorkingSetSize) || 0) / 1024 / 1024),
-  }));
-}
-
-/**
- * Unix: ps aux 파싱
- * @param {Function} execFileFn - DI용 execFile 구현
- * @returns {Promise<Array<{pid,name,parentPid,cmdLine,ramMB}>>}
- */
-async function queryUnixProcesses(execFileFn) {
-  const { stdout } = await execFileFn(
-    "ps",
-    ["-eo", "pid=,ppid=,rss=,comm=,args="],
-    { encoding: "utf8", timeout: 10_000 },
-  );
-
-  return stdout
-    .trim()
-    .split("\n")
-    .filter(Boolean)
-    .map((line) => {
-      const parts = line.trim().split(/\s+/);
-      const pid = Number(parts[0]);
-      const parentPid = Number(parts[1]);
-      const ramMB = Math.round((Number(parts[2]) || 0) / 1024);
-      const name = String(parts[3] || "");
-      const cmdLine = parts.slice(4).join(" ");
-      return { pid, name, parentPid, cmdLine, ramMB };
-    });
-}
-
-/**
- * 프로세스 시작 시각을 Unix 기준 ms로 조회 (Windows 전용, best-effort)
- * @param {number} pid
- * @param {Function} execFileFn
- * @returns {Promise<number>} epoch ms, 실패 시 0
- */
-async function getWindowsProcessStartMs(pid, execFileFn) {
-  try {
-    const script = `(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}').CreationDate | Get-Date -Format 'o'`;
-    const { stdout } = await execFileFn(
-      "pwsh",
-      ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script],
-      { encoding: "utf8", timeout: 5_000, windowsHide: true },
-    );
-    const ts = Date.parse(stdout.trim());
-    return Number.isNaN(ts) ? 0 : ts;
-  } catch {
-    return 0;
-  }
-}
-
-// ── 화이트리스트 판정 ──────────────────────────────────────────────────────
-
-/**
- * 프로세스가 화이트리스트에 해당하는지 판정
- * @param {{name:string, cmdLine:string}} proc
- * @param {Set<number>} parentPids - 화이트리스트 부모 PID 집합
- * @returns {boolean}
- */
-function isWhitelisted(proc, parentPids) {
-  const nameLower = proc.name.toLowerCase();
-
-  // 프로세스명 기반
-  if (WHITELIST_NAMES.some((n) => nameLower.includes(n.toLowerCase()))) {
-    return true;
-  }
-
-  // cmdLine 패턴 기반
-  if (WHITELIST_CMDLINE.some((re) => re.test(proc.cmdLine))) {
-    return true;
-  }
-
-  // CCXProcess 자식 (Adobe Creative Cloud)
-  if (parentPids.has(proc.parentPid)) {
-    return true;
-  }
-
-  return false;
-}
-
-// ── psmux 교차검증 ──────────────────────────────────────────────────────────
-
-/**
- * psmux list-sessions 결과에서 활성 세션 pane PID 집합을 수집
- * @param {Function} execFileFn
- * @returns {Promise<Set<number>>}
- */
-async function getActivePsmuxPids(execFileFn) {
-  try {
-    const { stdout: sessOut } = await execFileFn(
-      "psmux",
-      ["list-sessions", "-F", "#{session_name}"],
-      { encoding: "utf8", timeout: 5_000, windowsHide: true },
-    );
-
-    const sessions = sessOut.trim().split(/\r?\n/).filter(Boolean);
-    if (sessions.length === 0) return new Set();
-
-    const pids = new Set();
-
-    await Promise.all(
-      sessions.map(async (session) => {
-        try {
-          const { stdout: paneOut } = await execFileFn(
-            "psmux",
-            ["list-panes", "-t", session, "-a", "-F", "#{pane_pid}"],
-            { encoding: "utf8", timeout: 5_000, windowsHide: true },
-          );
-          paneOut
-            .trim()
-            .split(/\r?\n/)
-            .filter(Boolean)
-            .forEach((p) => {
-              const n = Number(p.trim());
-              if (n > 0) pids.add(n);
-            });
-        } catch {
-          // 세션 쿼리 실패 시 해당 세션만 건너뜀
-        }
-      }),
-    );
-
-    return pids;
-  } catch {
-    // psmux 미설치 또는 실패 시 빈 집합 반환
-    return new Set();
-  }
-}
-
-// ── 공개 API ────────────────────────────────────────────────────────────────
-
-/**
- * 고아 프로세스 목록을 반환한다.
- *
- * @param {object} [opts]
- * @param {Function} [opts.execFileFn] - DI용 execFile (기본: node:child_process.execFile의 promisify 버전)
- * @param {boolean} [opts.skipPsmuxCheck] - psmux 교차검증 생략 (테스트용)
- * @returns {Promise<Array<{pid,name,ramMB,parentPid,cmdLine,age}>>}
- */
-export async function findOrphanProcesses(opts = {}) {
-  const execFileFn = opts.execFileFn ?? execFileAsync;
-
-  let allProcs;
-  try {
-    allProcs = IS_WINDOWS
-      ? await queryWindowsProcesses(execFileFn)
-      : await queryUnixProcesses(execFileFn);
-  } catch {
-    return [];
-  }
-
-  if (allProcs.length === 0) return [];
-
-  const pidSet = new Set(allProcs.map((p) => p.pid));
-
-  // CCXProcess 부모 PID 집합 구성
-  const ccxParentPids = new Set(
-    allProcs
-      .filter((p) => p.name.toLowerCase() === "ccxprocess")
-      .map((p) => p.pid),
-  );
-
-  // 활성 psmux PID 교차검증
-  const activePsmuxPids = opts.skipPsmuxCheck
-    ? new Set()
-    : await getActivePsmuxPids(execFileFn);
-
-  const now = Date.now();
-
-  const candidates = allProcs.filter((p) => {
-    const nameLower = p.name.toLowerCase();
-
-    // 대상 프로세스만
-    if (
-      !TARGET_PROCESS_NAMES.some(
-        (t) => nameLower === t || nameLower === `${t}.exe`,
-      )
-    ) {
-      return false;
-    }
-
-    // 화이트리스트
-    if (isWhitelisted(p, ccxParentPids)) return false;
-
-    // 활성 psmux 세션 소속 PID 제외
-    if (activePsmuxPids.has(p.pid)) return false;
-
-    // 부모가 없거나(0, 1 제외 시 존재하지 않는 PID) 고아
-    const parentAlive = p.parentPid <= 1 || pidSet.has(p.parentPid);
-    if (parentAlive) return false;
-
-    return true;
-  });
-
-  // age 계산 (Windows만 best-effort, Unix는 0)
-  const results = await Promise.all(
-    candidates.map(async (p) => {
-      let startMs = 0;
-      if (IS_WINDOWS) {
-        startMs = await getWindowsProcessStartMs(p.pid, execFileFn);
-      }
-      return {
-        pid: p.pid,
-        name: p.name,
-        ramMB: p.ramMB,
-        parentPid: p.parentPid,
-        cmdLine: p.cmdLine,
-        age: startMs > 0 ? now - startMs : 0,
-      };
-    }),
-  );
-
-  return results;
-}
-
-/**
- * createProcessCleanup — scan/kill/getOrphans 인터페이스를 반환한다.
- *
- * @param {object} [opts]
- * @param {Function} [opts.execFileFn] - DI용 execFile (promisify된 버전)
- * @param {boolean} [opts.dryRun] - true이면 kill 없이 목록만 반환
- * @param {boolean} [opts.skipPsmuxCheck] - psmux 교차검증 생략 (테스트용)
- * @returns {{ scan: Function, kill: Function, getOrphans: Function }}
- */
-export function createProcessCleanup(opts = {}) {
-  const execFileFn = opts.execFileFn ?? execFileAsync;
-  const dryRun = opts.dryRun ?? false;
-  const isWindows = opts.isWindows ?? IS_WINDOWS;
-  const execFileSyncFn = opts.execFileSyncFn ?? execFileSync;
-  const killFn = opts.killFn ?? process.kill;
-  const sleepFn =
-    opts.sleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-  const sigtermGraceMs = opts.sigtermGraceMs ?? SIGTERM_GRACE_MS;
-
-  let lastOrphans = [];
-
-  /**
-   * 고아 프로세스를 스캔하여 내부 상태에 저장하고 목록을 반환한다.
-   * @returns {Promise<Array<{pid,name,ramMB,parentPid,cmdLine,age}>>}
-   */
-  async function scan() {
-    const found = await findOrphanProcesses({
-      execFileFn,
-      skipPsmuxCheck: opts.skipPsmuxCheck,
-    });
-    lastOrphans = found;
-    return found;
-  }
-
-  /**
-   * 마지막 scan 결과의 프로세스를 kill한다.
-   * dryRun=true이면 kill 없이 목록만 반환한다.
-   * SIGTERM → 5s 대기 → 강제 종료(taskkill/SIGKILL) 순서.
-   * @returns {Promise<Array<{pid,name,killed,error}>>}
-   */
-  async function kill() {
-    if (dryRun) {
-      return lastOrphans.map((p) => ({
-        pid: p.pid,
-        name: p.name,
-        killed: false,
-        dryRun: true,
-      }));
-    }
-
-    const results = await Promise.all(
-      lastOrphans.map(async (p) => {
-        try {
-          // SIGTERM
-          killFn(p.pid, "SIGTERM");
-
-          // 5초 대기 후 살아있으면 강제 종료
-          await sleepFn(sigtermGraceMs);
-
-          try {
-            // 프로세스가 아직 살아있는지 확인 (signal 0)
-            killFn(p.pid, 0);
-            // 여전히 살아있음 → Windows는 taskkill/process.kill, 그 외는 SIGKILL
-            forceKillPid(p.pid, { isWindows, execFileSyncFn, killFn });
-          } catch {
-            // ESRCH: 이미 종료됨 — 정상
-          }
-
-          return { pid: p.pid, name: p.name, killed: true };
-        } catch (err) {
-          return {
-            pid: p.pid,
-            name: p.name,
-            killed: false,
-            error: String(err.message || err),
-          };
-        }
-      }),
-    );
-
-    return results;
-  }
-
-  /**
-   * 마지막 scan 결과를 반환한다 (재스캔 없음).
-   * @returns {Array<{pid,name,ramMB,parentPid,cmdLine,age}>}
-   */
-  function getOrphans() {
-    return lastOrphans;
-  }
-
-  return { scan, kill, getOrphans };
-}

package/hub/team/routing.mjs

@@ -1,249 +0,0 @@
-/**
- * 라우팅 결정 함수
- * @param {object} opts
- * @param {Array<{id:string, description?:string, agent?:string, depends_on?:string[], complexity?:string}>} opts.subtasks
- * @param {string} opts.graph_type - "INDEPENDENT" | "SEQUENTIAL" | "DAG"
- * @param {boolean} opts.thorough - thorough 모드 여부
- * @returns {{
- *   strategy: "quick_single" | "thorough_single" | "quick_team" | "thorough_team" | "batch_single",
- *   reason: string,
- *   dag_width: number,
- *   max_complexity: string,
- *   dagContext: { dag_width: number, levels: Record<number, string[]>, edges: Array<{from:string, to:string}>, max_complexity: string, taskResults: Record<string, *> }
- * }}
- */
-export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
-  const N = subtasks.length;
-  if (N === 0) {
-    const dagContext = {
-      dag_width: 0,
-      levels: {},
-      edges: [],
-      max_complexity: "S",
-      taskResults: {},
-    };
-    return {
-      strategy: "quick_single",
-      reason: "empty_subtasks",
-      dag_width: 0,
-      max_complexity: "S",
-      dagContext,
-    };
-  }
-
-  const {
-    width: dag_width,
-    levels,
-    edges,
-  } = computeDagInfo(subtasks, graph_type);
-  const max_complexity = getMaxComplexity(subtasks);
-  const dagContext = {
-    dag_width,
-    levels,
-    edges,
-    max_complexity,
-    taskResults: {},
-  };
-  const isHighComplexity = ["L", "XL"].includes(max_complexity);
-  const allSameAgent = new Set(subtasks.map((s) => s.agent)).size === 1;
-  const allSmall = subtasks.every(
-    (s) => normalizeComplexity(s.complexity) === "S",
-  );
-
-  // N==1: 단일 태스크
-  if (N === 1) {
-    if (thorough || isHighComplexity) {
-      return {
-        strategy: "thorough_single",
-        reason: "single_high_complexity",
-        dag_width,
-        max_complexity,
-        dagContext,
-      };
-    }
-    return {
-      strategy: "quick_single",
-      reason: "single_low_complexity",
-      dag_width,
-      max_complexity,
-      dagContext,
-    };
-  }
-
-  // dag_width==1: 사실상 순차 -> single
-  if (dag_width === 1) {
-    if (thorough || isHighComplexity) {
-      return {
-        strategy: "thorough_single",
-        reason: "sequential_chain",
-        dag_width,
-        max_complexity,
-        dagContext,
-      };
-    }
-    return {
-      strategy: "quick_single",
-      reason: "sequential_chain",
-      dag_width,
-      max_complexity,
-      dagContext,
-    };
-  }
-
-  // 동일 에이전트 + 모두 S: 프롬프트 병합 -> batch single
-  if (allSameAgent && allSmall) {
-    return {
-      strategy: "batch_single",
-      reason: "same_agent_small_batch",
-      dag_width,
-      max_complexity,
-      dagContext,
-    };
-  }
-
-  // dag_width >= 2: 팀
-  if (thorough || isHighComplexity) {
-    return {
-      strategy: "thorough_team",
-      reason: "parallel_high_complexity",
-      dag_width,
-      max_complexity,
-      dagContext,
-    };
-  }
-  return {
-    strategy: "quick_team",
-    reason: "parallel_low_complexity",
-    dag_width,
-    max_complexity,
-    dagContext,
-  };
-}
-
-/**
- * DAG 정보 계산 — 레벨별 태스크 배열, 간선, 최대 폭
- * @param {Array<{id:string, depends_on?:string[]}>} subtasks
- * @param {string} graph_type
- * @returns {{ width: number, levels: Record<number, string[]>, edges: Array<{from:string, to:string}> }}
- */
-function computeDagInfo(subtasks, graph_type) {
-  if (graph_type === "SEQUENTIAL") {
-    const levels = {};
-    const edges = [];
-    subtasks.forEach((t, i) => {
-      levels[i] = [t.id];
-      if (i > 0) edges.push({ from: subtasks[i - 1].id, to: t.id });
-    });
-    return { width: 1, levels, edges };
-  }
-  if (graph_type === "INDEPENDENT") {
-    const levels = { 0: subtasks.map((t) => t.id) };
-    return { width: subtasks.length, levels, edges: [] };
-  }
-
-  // DAG: 레벨별 계산 (순환 의존 방어)
-  const taskLevels = {};
-  const visiting = new Set();
-
-  function getLevel(task) {
-    if (taskLevels[task.id] !== undefined) return taskLevels[task.id];
-    if (visiting.has(task.id)) {
-      taskLevels[task.id] = 0; // 순환 끊기
-      return 0;
-    }
-    if (!task.depends_on || task.depends_on.length === 0) {
-      taskLevels[task.id] = 0;
-      return 0;
-    }
-    visiting.add(task.id);
-    const depLevels = task.depends_on.map((depId) => {
-      const dep = subtasks.find((s) => s.id === depId);
-      return dep ? getLevel(dep) : 0;
-    });
-    visiting.delete(task.id);
-    taskLevels[task.id] = Math.max(...depLevels) + 1;
-    return taskLevels[task.id];
-  }
-
-  subtasks.forEach(getLevel);
-
-  // 레벨별 태스크 그룹핑
-  const levels = {};
-  for (const [id, level] of Object.entries(taskLevels)) {
-    if (!levels[level]) levels[level] = [];
-    levels[level].push(id);
-  }
-
-  // 간선 수집
-  const edges = [];
-  for (const task of subtasks) {
-    if (task.depends_on) {
-      for (const depId of task.depends_on) {
-        edges.push({ from: depId, to: task.id });
-      }
-    }
-  }
-
-  const width = Math.max(...Object.values(levels).map((arr) => arr.length), 1);
-  return { width, levels, edges };
-}
-
-/**
- * 선행 태스크의 결과를 dagContext.edges에서 조회하여 반환
- * @param {string} taskId - 조회 대상 태스크 ID
- * @param {{ dagContext?: { edges: Array<{from:string, to:string}>, taskResults: Record<string, *> } }} pipelineState
- * @returns {Record<string, *>} 선행 태스크 ID → 결과 매핑
- */
-export function getUpstreamResults(taskId, pipelineState) {
-  const ctx = pipelineState?.dagContext;
-  if (!ctx) return {};
-  const upstreamIds = ctx.edges
-    .filter((e) => e.to === taskId)
-    .map((e) => e.from);
-  const results = {};
-  for (const id of upstreamIds) {
-    if (id in (ctx.taskResults || {})) {
-      results[id] = ctx.taskResults[id];
-    }
-  }
-  return results;
-}
-
-/**
- * 태스크 완료 시 결과를 dagContext에 기록
- * @param {string} taskId - 완료된 태스크 ID
- * @param {*} result - 태스크 결과
- * @param {{ dagContext?: { taskResults: Record<string, *> } }} pipelineState
- * @returns {boolean} 기록 성공 여부
- */
-export function updateTaskResult(taskId, result, pipelineState) {
-  const ctx = pipelineState?.dagContext;
-  if (!ctx) return false;
-  if (!ctx.taskResults) ctx.taskResults = {};
-  ctx.taskResults[taskId] = result;
-  return true;
-}
-
-/**
- * 최대 복잡도 추출
- * @param {Array<{complexity?:string}>} subtasks
- * @returns {"S" | "M" | "L" | "XL"}
- */
-function getMaxComplexity(subtasks) {
-  const order = { S: 0, M: 1, L: 2, XL: 3 };
-  let max = "S";
-  for (const s of subtasks) {
-    const complexity = normalizeComplexity(s.complexity);
-    if (order[complexity] > order[max]) max = complexity;
-  }
-  return max;
-}
-
-/**
- * complexity 기본값 보정
- * @param {string | undefined} complexity
- * @returns {"S" | "M" | "L" | "XL"}
- */
-function normalizeComplexity(complexity) {
-  return ["S", "M", "L", "XL"].includes(complexity) ? complexity : "M";
-}