@triflux/remote 10.0.0-alpha.1 → 10.0.0-alpha.2

package/hub/team/event-log.mjs

@@ -0,0 +1,76 @@
+// hub/team/event-log.mjs — JSONL 블랙박스 리코더
+// Conductor 세션 lifecycle 이벤트를 JSONL 파일에 기록한다.
+// 기존 hub/server.mjs의 batch-events.jsonl(MCP 이벤트)과 독립. 공존.
+
+import { createWriteStream, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+/**
+ * JSONL event log 팩토리.
+ * @param {string} filePath — 로그 파일 경로 (.jsonl)
+ * @param {object} [opts]
+ * @param {string} [opts.sessionId] — 모든 이벤트에 자동 삽입할 세션 ID
+ * @returns {{ append, flush, close, filePath }}
+ */
+export function createEventLog(filePath, opts = {}) {
+  const { sessionId } = opts;
+
+  mkdirSync(dirname(filePath), { recursive: true });
+  const stream = createWriteStream(filePath, { flags: 'a' });
+
+  let closed = false;
+  let pending = 0;
+
+  /**
+   * 이벤트를 JSONL 한 줄로 기록.
+   * @param {string} event — 이벤트 타입 (spawn, health, kill, stateChange, ...)
+   * @param {object} [data] — 이벤트 페이로드
+   */
+  function append(event, data = {}) {
+    if (closed) return;
+    const entry = {
+      ts: new Date().toISOString(),
+      ...(sessionId ? { session: sessionId } : {}),
+      event,
+      ...data,
+    };
+    pending += 1;
+    stream.write(JSON.stringify(entry) + '\n', () => { pending -= 1; });
+  }
+
+  /**
+   * 버퍼된 이벤트를 디스크에 flush.
+   * @returns {Promise<void>}
+   */
+  function flush() {
+    if (closed) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      stream.once('error', reject);
+      stream.write('', () => {
+        stream.removeListener('error', reject);
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * 스트림 종료. flush 후 close.
+   * @returns {Promise<void>}
+   */
+  function close() {
+    if (closed) return Promise.resolve();
+    closed = true;
+    return new Promise((resolve) => {
+      stream.end(() => resolve());
+    });
+  }
+
+  return Object.freeze({
+    append,
+    flush,
+    close,
+    get filePath() { return filePath; },
+    get pending() { return pending; },
+    get closed() { return closed; },
+  });
+}

package/hub/team/headless.mjs

@@ -9,6 +9,7 @@ import { tmpdir } from "node:os";
 import { execSync, spawn } from "node:child_process";
 import { createRequire } from "node:module";
 import { randomUUID } from "node:crypto";
+import { escapePwshSingleQuoted } from "@triflux/core/hub/cli-adapter-base.mjs";
 import {
   createPsmuxSession,
   killPsmuxSession,
@@ -26,11 +27,6 @@ import { createLogDashboard } from "./tui.mjs";
 
 const RESULT_DIR = join(tmpdir(), "tfx-headless");
 
-// remote-spawn.mjs의 escapePwshSingleQuoted와 동일 — 순환 의존 방지를 위해 인라인
-function escapePwshSingleQuoted(value) {
-  return String(value).replace(/'/g, "''");
-}
-
 /** CLI별 브랜드 — 이모지 + 공식 색상 (HUD와 통일) */
 const CLI_BRAND = {
   codex:  { emoji: "\u{26AA}", label: "Codex",  ansi: "\x1b[97m" },   // ⚪ bright white (codexWhite)
@@ -121,7 +117,13 @@ function readResult(resultFile, paneId) {
   if (existsSync(resultFile)) {
     return readFileSync(resultFile, "utf8").trim();
   }
-  // fallback: capture-pane (paneId = "tfx:0.1" 형태)
+  // fallback 1: stderr 파일 (codex 실패 시 원인 추적)
+  const errFile = `${resultFile}.err`;
+  if (existsSync(errFile)) {
+    const stderr = readFileSync(errFile, "utf8").trim();
+    if (stderr) return `[stderr] ${stderr}`;
+  }
+  // fallback 2: capture-pane (paneId = "tfx:0.1" 형태)
   return capturePsmuxPane(paneId, 30);
 }
 

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 '@triflux/core/hub/codex-adapter.mjs';
+import { buildExecArgs as buildGeminiArgs } from '@triflux/core/hub/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,
+    };
+  }
+}

package/hub/team/nativeProxy.mjs

@@ -19,8 +19,8 @@ import {
 import { basename, dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 import { randomUUID } from 'node:crypto';
-import { isPidAlive } from '../lib/process-utils.mjs';
-import { IS_WINDOWS } from '../platform.mjs';
+import { isPidAlive } from '@triflux/core/hub/lib/process-utils.mjs';
+import { IS_WINDOWS } from '@triflux/core/hub/platform.mjs';
 
 const TEAM_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
 const CLAUDE_HOME = join(homedir(), '.claude');
@@ -679,3 +679,10 @@ export async function teamSendMessage(args = {}) {
     return err('SEND_MESSAGE_FAILED', e.message);
   }
 }
+
+export const nativeProxy = Object.freeze({
+  teamInfo,
+  teamTaskList,
+  teamTaskUpdate,
+  teamSendMessage,
+});