triflux 10.0.0 → 10.0.2

package/hub/team/health-probe.mjs

@@ -0,0 +1,272 @@
+// hub/team/health-probe.mjs — 4단계 health model + INPUT_WAIT 감지
+// 기존 cli-adapter-base.mjs:stallThresholdMs(30s)와 headless.mjs:STALL_DEFAULTS(120s)를
+// 4단계 probe 모델로 교체. stdout+stderr 통합 스트림으로 평가 (F3 해결).
+
+/**
+ * Health probe level 정의.
+ * L0: Process alive (PID 존재 + exit code 없음)
+ * L1: Output advancing (stdout+stderr 통합, 30s)
+ * L1.5: INPUT_WAIT 감지 (질문 패턴이면 stall이 아니라 input-wait)
+ * L2: MCP connected (opt-in, heartbeat, 30s)
+ * L3: Prompt acknowledged (첫 tool call/텍스트, 120s)
+ */
+export const PROBE_LEVELS = Object.freeze({
+  L0: 'alive',
+  L1: 'advancing',
+  L2: 'mcp_connected',
+  L3: 'prompt_ack',
+});
+
+/** 기본 설정 (기존 stallThresholdMs/stallTimeout 값 계승) */
+export const PROBE_DEFAULTS = Object.freeze({
+  intervalMs: 5_000,
+  probeTimeoutMs: 5_000,
+  l1ThresholdMs: 30_000,
+  l2ThresholdMs: 30_000,
+  l3ThresholdMs: 120_000,
+  enableL2: false,
+});
+
+/**
+ * stdin 입력 대기 패턴 (Codex 질문 블로킹 감지)
+ * Codex가 질문하며 stdin을 기다리는 경우 stall이 아니라 INPUT_WAIT로 분류.
+ */
+const INPUT_WAIT_PATTERNS = [
+  /\?\s*$/m,                          // 물음표로 끝나는 줄
+  /\b(y\/n|yes\/no)\b/i,             // y/n 프롬프트
+  /\b(choose|select|pick)\b.*:/i,    // choose/select 프롬프트
+  /\b(confirm|approve|proceed)\b/i,  // confirm 프롬프트
+  /\b(enter|input|type)\b.*:/i,      // 입력 요청
+  /\[.*\]:\s*$/m,                     // [default]: 형태
+  />\s*$/m,                           // > 프롬프트
+];
+
+/**
+ * 최근 output에서 INPUT_WAIT 패턴 감지.
+ * @param {string} recentOutput — 최근 stdout+stderr 통합 텍스트
+ * @returns {{ detected: boolean, pattern: string|null }}
+ */
+export function detectInputWait(recentOutput) {
+  if (!recentOutput) return { detected: false, pattern: null };
+  // 마지막 5줄만 검사 (전체 output이 아닌 최근 출력)
+  const lines = recentOutput.split(/\r?\n/).filter(Boolean).slice(-5).join('\n');
+  for (const re of INPUT_WAIT_PATTERNS) {
+    if (re.test(lines)) {
+      return { detected: true, pattern: re.source };
+    }
+  }
+  return { detected: false, pattern: null };
+}
+
+/**
+ * Health probe 팩토리.
+ * @param {object} session — probe 대상 세션 상태 객체
+ * @param {number|null} session.pid — 프로세스 PID
+ * @param {function} session.getRecentOutput — () => string (최근 stdout+stderr)
+ * @param {function} session.getOutputBytes — () => number (총 output 바이트)
+ * @param {boolean} [session.alive] — 프로세스 alive 여부 (외부 업데이트)
+ * @param {object} [opts] — PROBE_DEFAULTS 오버라이드
+ * @param {function} [opts.onProbe] — (level, result) => void 콜백
+ * @param {function} [opts.checkMcp] — () => Promise<boolean> MCP heartbeat 체커 (L2용)
+ * @returns {{ start, stop, probe, getStatus }}
+ */
+export function createHealthProbe(session, opts = {}) {
+  const config = { ...PROBE_DEFAULTS, ...opts };
+  let timer = null;
+  let started = false;
+
+  // L1 tracking
+  let lastOutputBytes = 0;
+  let lastOutputChangeAt = Date.now();
+
+  // L3 tracking
+  let promptAcked = false;
+  let spawnedAt = Date.now();
+
+  const status = {
+    l0: null,  // 'ok' | 'fail'
+    l1: null,  // 'ok' | 'stall' | 'input_wait'
+    l2: null,  // 'ok' | 'fail' | 'skip'
+    l3: null,  // 'ok' | 'timeout'
+    lastProbeAt: null,
+    inputWaitPattern: null,
+  };
+
+  /**
+   * L0: Process alive check.
+   */
+  function probeL0() {
+    const alive = session.alive !== undefined
+      ? session.alive
+      : (session.pid != null && session.pid > 0);
+    status.l0 = alive ? 'ok' : 'fail';
+    return status.l0;
+  }
+
+  /**
+   * L1 + L1.5: Output advancing + INPUT_WAIT 감지.
+   */
+  function probeL1() {
+    const currentBytes = typeof session.getOutputBytes === 'function'
+      ? session.getOutputBytes()
+      : 0;
+
+    const now = Date.now();
+
+    if (currentBytes !== lastOutputBytes) {
+      lastOutputBytes = currentBytes;
+      lastOutputChangeAt = now;
+      status.l1 = 'ok';
+      status.inputWaitPattern = null;
+      return 'ok';
+    }
+
+    const silenceMs = now - lastOutputChangeAt;
+
+    if (silenceMs >= config.l1ThresholdMs) {
+      // L1.5: INPUT_WAIT 감지 — stall 전에 질문 패턴 체크
+      const recentOutput = typeof session.getRecentOutput === 'function'
+        ? session.getRecentOutput()
+        : '';
+      const inputWait = detectInputWait(recentOutput);
+
+      if (inputWait.detected) {
+        status.l1 = 'input_wait';
+        status.inputWaitPattern = inputWait.pattern;
+        return 'input_wait';
+      }
+
+      status.l1 = 'stall';
+      status.inputWaitPattern = null;
+      return 'stall';
+    }
+
+    // 아직 threshold 미달
+    status.l1 = 'ok';
+    return 'ok';
+  }
+
+  /**
+   * L2: MCP connected (opt-in).
+   */
+  async function probeL2() {
+    if (!config.enableL2) {
+      status.l2 = 'skip';
+      return 'skip';
+    }
+    if (typeof config.checkMcp !== 'function') {
+      status.l2 = 'skip';
+      return 'skip';
+    }
+    try {
+      const connected = await Promise.race([
+        config.checkMcp(),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('probe_timeout')), config.probeTimeoutMs)
+        ),
+      ]);
+      status.l2 = connected ? 'ok' : 'fail';
+    } catch {
+      status.l2 = 'fail';
+    }
+    return status.l2;
+  }
+
+  /**
+   * L3: Prompt acknowledged.
+   * 첫 번째 meaningful output이 나오면 ack.
+   */
+  function probeL3() {
+    if (promptAcked) {
+      status.l3 = 'ok';
+      return 'ok';
+    }
+
+    const currentBytes = typeof session.getOutputBytes === 'function'
+      ? session.getOutputBytes()
+      : 0;
+
+    if (currentBytes > 0) {
+      promptAcked = true;
+      status.l3 = 'ok';
+      return 'ok';
+    }
+
+    const elapsed = Date.now() - spawnedAt;
+    if (elapsed >= config.l3ThresholdMs) {
+      status.l3 = 'timeout';
+      return 'timeout';
+    }
+
+    status.l3 = null; // 아직 판정 전
+    return null;
+  }
+
+  /**
+   * 전체 probe 실행 (L0→L1→L2→L3).
+   * @returns {Promise<object>} probe 결과
+   */
+  async function probe() {
+    const result = {
+      l0: probeL0(),
+      l1: probeL1(),
+      l2: await probeL2(),
+      l3: probeL3(),
+      inputWaitPattern: status.inputWaitPattern,
+      ts: Date.now(),
+    };
+    status.lastProbeAt = result.ts;
+
+    if (typeof config.onProbe === 'function') {
+      config.onProbe(result);
+    }
+
+    return result;
+  }
+
+  function start() {
+    if (started) return;
+    started = true;
+    spawnedAt = Date.now();
+    lastOutputChangeAt = Date.now();
+    lastOutputBytes = 0;
+    promptAcked = false;
+
+    timer = setInterval(() => { void probe(); }, config.intervalMs);
+    timer.unref?.();
+
+    // 즉시 첫 probe 실행
+    void probe();
+  }
+
+  function stop() {
+    if (!started) return;
+    started = false;
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+
+  /** L1 tracking 리셋 (restart 후 호출) */
+  function resetTracking() {
+    lastOutputBytes = 0;
+    lastOutputChangeAt = Date.now();
+    promptAcked = false;
+    spawnedAt = Date.now();
+    status.l0 = null;
+    status.l1 = null;
+    status.l2 = null;
+    status.l3 = null;
+    status.inputWaitPattern = null;
+  }
+
+  return Object.freeze({
+    start,
+    stop,
+    probe,
+    resetTracking,
+    getStatus: () => ({ ...status }),
+    get started() { return started; },
+  });
+}

package/hub/team/launcher-template.mjs

@@ -0,0 +1,95 @@
+// hub/team/launcher-template.mjs — 결정론적 런처 생성
+// 기존 codex-adapter/gemini-adapter의 buildExecArgs를 소비하여
+// 동일 입력 → 동일 args 배열을 보장한다.
+// F1 해결: codex adapter가 --dangerously-bypass-approvals-and-sandbox 자동 추가
+// F4 해결: codex exec "prompt" 인라인 (파이프/리다이렉트 아님)
+// F5 해결: 동일 입력 → 동일 args 배열 (런타임 분기 없음)
+
+import { buildExecArgs as buildCodexArgs } from '../codex-adapter.mjs';
+import { buildExecArgs as buildGeminiArgs } from '../gemini-adapter.mjs';
+
+/** CLI별 adapter 레지스트리 */
+const ADAPTERS = Object.freeze({
+  codex: {
+    bin: 'codex',
+    buildArgs: buildCodexArgs,
+    env: (profile) => (profile ? { CODEX_PROFILE: profile } : {}),
+  },
+  gemini: {
+    bin: 'gemini',
+    buildArgs: buildGeminiArgs,
+    env: () => ({}),
+  },
+  claude: {
+    bin: 'claude',
+    buildArgs: (opts = {}) => {
+      const parts = ['claude'];
+      if (opts.model) parts.push('--model', opts.model);
+      parts.push('-p', JSON.stringify(opts.prompt || ''));
+      return parts.join(' ');
+    },
+    env: () => ({}),
+  },
+});
+
+/**
+ * CLI adapter 조회.
+ * @param {'codex'|'gemini'|'claude'} agent
+ * @returns {object} adapter — { bin, buildArgs, env }
+ * @throws {Error} 알 수 없는 agent
+ */
+export function getAdapter(agent) {
+  const adapter = ADAPTERS[agent];
+  if (!adapter) {
+    throw new Error(`Unknown agent: "${agent}". Supported: ${Object.keys(ADAPTERS).join(', ')}`);
+  }
+  return adapter;
+}
+
+/**
+ * 결정론적 런처 생성.
+ * 동일 입력이면 항상 동일한 { bin, command, env } 반환.
+ *
+ * @param {object} opts
+ * @param {'codex'|'gemini'|'claude'} opts.agent — CLI 타입
+ * @param {string} [opts.profile] — CLI 프로파일
+ * @param {string} opts.prompt — 실행할 프롬프트
+ * @param {string} [opts.workdir] — 작업 디렉토리
+ * @param {string} [opts.model] — 모델 오버라이드
+ * @param {string} [opts.resultFile] — 결과 저장 경로
+ * @returns {{ bin: string, command: string, env: object, agent: string }}
+ */
+export function buildLauncher(opts) {
+  const { agent, profile, prompt, workdir, model, resultFile, mcpServers } = opts;
+
+  if (!agent) throw new Error('agent is required');
+  if (!prompt && prompt !== '') throw new Error('prompt is required');
+
+  const adapter = getAdapter(agent);
+
+  const command = adapter.buildArgs({
+    prompt,
+    profile,
+    model,
+    resultFile,
+    workdir,
+    mcpServers,
+  });
+
+  const env = adapter.env(profile);
+
+  return Object.freeze({
+    bin: adapter.bin,
+    command,
+    env,
+    agent,
+  });
+}
+
+/**
+ * 지원되는 agent 목록.
+ * @returns {string[]}
+ */
+export function listAgents() {
+  return Object.keys(ADAPTERS);
+}

package/hub/team/lead-control.mjs

@@ -0,0 +1,104 @@
+const DEFAULT_TIMEOUT_MS = 2500;
+const CONTROL_COMMAND_ALIASES = Object.freeze({
+  stop: "abort",
+  interrupt: "abort",
+});
+
+export const LEAD_CONTROL_COMMANDS = Object.freeze(["pause", "resume", "abort", "reassign"]);
+
+function resolveFetch(fetchImpl) {
+  if (typeof fetchImpl === "function") return fetchImpl;
+  if (typeof globalThis.fetch === "function") return globalThis.fetch.bind(globalThis);
+  return null;
+}
+
+function normalizeHubBaseUrl(hubUrl) {
+  return String(hubUrl || "").replace(/\/+$/, "").replace(/\/mcp$/, "");
+}
+
+function normalizeCommand(command) {
+  const raw = String(command || "").trim().toLowerCase();
+  if (!raw) return "";
+  return CONTROL_COMMAND_ALIASES[raw] || raw;
+}
+
+function safeAbortSignal(timeoutMs) {
+  if (typeof AbortSignal?.timeout !== "function") return undefined;
+  return AbortSignal.timeout(timeoutMs);
+}
+
+function safeJson(res) {
+  return res.json().catch(() => ({}));
+}
+
+export async function publishLeadControl({
+  hubUrl,
+  fromAgent = "lead",
+  toAgent,
+  command,
+  reason = "",
+  payload = {},
+  traceId,
+  correlationId,
+  ttlMs = 3600000,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  fetchImpl,
+} = {}) {
+  const requestFetch = resolveFetch(fetchImpl);
+  if (!requestFetch) {
+    return { ok: false, error: "FETCH_UNAVAILABLE" };
+  }
+
+  const hubBase = normalizeHubBaseUrl(hubUrl);
+  if (!hubBase) {
+    return { ok: false, error: "HUB_URL_REQUIRED" };
+  }
+
+  const targetAgent = String(toAgent || "").trim();
+  if (!targetAgent) {
+    return { ok: false, error: "TARGET_AGENT_REQUIRED" };
+  }
+
+  const normalizedCommand = normalizeCommand(command);
+  if (!LEAD_CONTROL_COMMANDS.includes(normalizedCommand)) {
+    return {
+      ok: false,
+      error: "INVALID_COMMAND",
+      allowed: LEAD_CONTROL_COMMANDS,
+      command: normalizedCommand,
+    };
+  }
+
+  try {
+    const res = await requestFetch(`${hubBase}/bridge/control`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        from_agent: String(fromAgent || "lead"),
+        to_agent: targetAgent,
+        command: normalizedCommand,
+        reason: String(reason || ""),
+        payload: payload && typeof payload === "object" ? payload : {},
+        ttl_ms: ttlMs,
+        trace_id: traceId,
+        correlation_id: correlationId,
+      }),
+      signal: safeAbortSignal(timeoutMs),
+    });
+
+    const body = await safeJson(res);
+    return {
+      ok: res.ok && body?.ok !== false,
+      status: res.status,
+      body,
+      command: normalizedCommand,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      error: "CONTROL_PUBLISH_FAILED",
+      message: error?.message || "control publish failed",
+      command: normalizedCommand,
+    };
+  }
+}