@triflux/remote 10.1.0 → 10.26.0

package/hub/team/health-probe.mjs

@@ -2,6 +2,10 @@
 // 기존 cli-adapter-base.mjs:stallThresholdMs(30s)와 headless.mjs:STALL_DEFAULTS(120s)를
 // 4단계 probe 모델로 교체. stdout+stderr 통합 스트림으로 평가 (F3 해결).
 
+import { mkdirSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
 /**
  * Health probe level 정의.
  * L0: Process alive (PID 존재 + exit code 없음)
@@ -11,10 +15,10 @@
  * L3: Prompt acknowledged (첫 tool call/텍스트, 120s)
  */
 export const PROBE_LEVELS = Object.freeze({
-  L0: 'alive',
-  L1: 'advancing',
-  L2: 'mcp_connected',
-  L3: 'prompt_ack',
+  L0: "alive",
+  L1: "advancing",
+  L2: "mcp_connected",
+  L3: "prompt_ack",
 });
 
 /** 기본 설정 (기존 stallThresholdMs/stallTimeout 값 계승) */
@@ -24,7 +28,12 @@ export const PROBE_DEFAULTS = Object.freeze({
   l1ThresholdMs: 30_000,
   l2ThresholdMs: 30_000,
   l3ThresholdMs: 120_000,
-  enableL2: false,
+  // #168 P3: default off → on. checkMcp 미주입 시에도 probeL2 가 skip 반환하므로
+  // safe. conductor wiring 이 checkMcp 를 주입하면 실제 L2 판정이 활성화된다.
+  // opt-out: TFX_PROBE_L2=0 (conductor 에서 false 주입).
+  enableL2: true,
+  writeStateFile: false,
+  stateDir: join(tmpdir(), "tfx-probe"),
 });
 
 /**
@@ -32,13 +41,13 @@ export const PROBE_DEFAULTS = Object.freeze({
  * 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,                           // > 프롬프트
+  /\?\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, // > 프롬프트
 ];
 
 /**
@@ -49,7 +58,11 @@ const INPUT_WAIT_PATTERNS = [
 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');
+  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 };
@@ -74,6 +87,16 @@ export function createHealthProbe(session, opts = {}) {
   const config = { ...PROBE_DEFAULTS, ...opts };
   let timer = null;
   let started = false;
+  // stopped flag는 in-flight probe()가 stop() 사이의 await 점에서
+  // writeState/unlink 와 race 하는 것을 막는다. start() 시 false 로 reset.
+  let stopped = false;
+  // P0 (#167 review): start() 마다 증가. probe() 가 시작 시 캡처 → writeState() 가 epoch
+  // 비교로 stop()→start() 사이의 in-flight 가 새 run 의 state 를 덮는 race 차단.
+  // stopped flag 만으로는 start() 가 stopped=false 로 reset 한 직후 race 못 막음.
+  let runEpoch = 0;
+  // P1-1 (#167 review): Set 으로 모든 in-flight probe 추적. interval 이 빨라 N+1 이 N 끝나기
+  // 전에 시작되면 단일 var 는 N 을 덮어써 stopAndDrain() 시 N 이 누락된다.
+  const inFlightProbes = new Set();
 
   // L1 tracking
   let lastOutputBytes = 0;
@@ -84,22 +107,114 @@ export function createHealthProbe(session, opts = {}) {
   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'
+    l0: null, // 'ok' | 'fail'
+    l1: null, // 'ok' | 'stall' | 'input_wait'
+    l2: null, // 'ok' | 'fail' | 'skip'
+    l3: null, // 'ok' | 'timeout'
     lastProbeAt: null,
     inputWaitPattern: null,
   };
 
+  function getStateFilePath() {
+    if (typeof config.stateFile === "string" && config.stateFile.length > 0) {
+      return config.stateFile;
+    }
+    const pid = session.pid;
+    if (pid == null || pid <= 0) return null;
+    return join(config.stateDir, `${pid}.json`);
+  }
+
+  function deriveState(result) {
+    if (result.l0 === "fail") return "exited";
+    if (result.l1 === "input_wait") return "input_wait";
+    if (result.l2 === "fail") return "mcp_initializing";
+    if (result.l1 === "stall") return "stalled";
+    if (result.l3 === "timeout") return "reasoning";
+    return "active";
+  }
+
+  function writeState(result, probeEpoch) {
+    // stop() 직후 in-flight probe()의 재생성 방지.
+    // P0 (#167): probeEpoch !== runEpoch 면 이전 run 의 stale probe 가 새 run 의 state 를
+    // 덮으려는 시도 → skip.
+    if (stopped) return;
+    if (probeEpoch !== undefined && probeEpoch !== runEpoch) return;
+    if (!config.writeStateFile && !config.stateFile) return;
+    const stateFile = getStateFilePath();
+    if (!stateFile) return;
+    const payload =
+      JSON.stringify(
+        {
+          pid: session.pid ?? null,
+          state: deriveState(result),
+          result,
+          updatedAt: new Date(result.ts).toISOString(),
+        },
+        null,
+        2,
+      ) + "\n";
+    // tmp+rename 으로 atomic write — heartbeat 의 sed 가 부분 파일을 읽는 race 제거.
+    // tmp 는 같은 디렉토리에 둬야 EXDEV (cross-device link) 가 안 난다.
+    const tmpPath = `${stateFile}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    try {
+      mkdirSync(dirname(stateFile), { recursive: true });
+      writeFileSync(tmpPath, payload, "utf8");
+      try {
+        renameSync(tmpPath, stateFile);
+      } catch (renameErr) {
+        // Windows: 대상이 존재할 때 EPERM/EACCES.
+        // P1-2 (#167 review): backup-then-swap 으로 기존 파일 보존. 옛 unlinkSync→renameSync
+        // 패턴은 1차 unlink 후 2차 rename 실패 시 기존 파일과 tmp 둘 다 잃었다.
+        if (
+          renameErr?.code === "EEXIST" ||
+          renameErr?.code === "EPERM" ||
+          renameErr?.code === "EACCES"
+        ) {
+          const backupPath = `${stateFile}.old-${process.pid}-${Date.now()}`;
+          let backupCreated = false;
+          try {
+            renameSync(stateFile, backupPath);
+            backupCreated = true;
+          } catch {
+            // backup 실패 (대상 없음/잠김) — 그래도 진행 (tmp→stateFile 시도)
+          }
+          try {
+            renameSync(tmpPath, stateFile);
+            if (backupCreated) {
+              try {
+                unlinkSync(backupPath);
+              } catch {}
+            }
+          } catch (secondErr) {
+            // 2차도 실패 → backup 복구해서 기존 파일 보존
+            if (backupCreated) {
+              try {
+                renameSync(backupPath, stateFile);
+              } catch {}
+            }
+            throw secondErr;
+          }
+        } else {
+          throw renameErr;
+        }
+      }
+    } catch {
+      // probe state is advisory only — tmp cleanup
+      try {
+        unlinkSync(tmpPath);
+      } catch {}
+    }
+  }
+
   /**
    * L0: Process alive check.
    */
   function probeL0() {
-    const alive = session.alive !== undefined
-      ? session.alive
-      : (session.pid != null && session.pid > 0);
-    status.l0 = alive ? 'ok' : 'fail';
+    const alive =
+      session.alive !== undefined
+        ? session.alive
+        : session.pid != null && session.pid > 0;
+    status.l0 = alive ? "ok" : "fail";
     return status.l0;
   }
 
@@ -107,43 +222,45 @@ export function createHealthProbe(session, opts = {}) {
    * L1 + L1.5: Output advancing + INPUT_WAIT 감지.
    */
   function probeL1() {
-    const currentBytes = typeof session.getOutputBytes === 'function'
-      ? session.getOutputBytes()
-      : 0;
+    const currentBytes =
+      typeof session.getOutputBytes === "function"
+        ? session.getOutputBytes()
+        : 0;
 
     const now = Date.now();
 
     if (currentBytes !== lastOutputBytes) {
       lastOutputBytes = currentBytes;
       lastOutputChangeAt = now;
-      status.l1 = 'ok';
+      status.l1 = "ok";
       status.inputWaitPattern = null;
-      return 'ok';
+      return "ok";
     }
 
     const silenceMs = now - lastOutputChangeAt;
 
     if (silenceMs >= config.l1ThresholdMs) {
       // L1.5: INPUT_WAIT 감지 — stall 전에 질문 패턴 체크
-      const recentOutput = typeof session.getRecentOutput === 'function'
-        ? session.getRecentOutput()
-        : '';
+      const recentOutput =
+        typeof session.getRecentOutput === "function"
+          ? session.getRecentOutput()
+          : "";
       const inputWait = detectInputWait(recentOutput);
 
       if (inputWait.detected) {
-        status.l1 = 'input_wait';
+        status.l1 = "input_wait";
         status.inputWaitPattern = inputWait.pattern;
-        return 'input_wait';
+        return "input_wait";
       }
 
-      status.l1 = 'stall';
+      status.l1 = "stall";
       status.inputWaitPattern = null;
-      return 'stall';
+      return "stall";
     }
 
     // 아직 threshold 미달
-    status.l1 = 'ok';
-    return 'ok';
+    status.l1 = "ok";
+    return "ok";
   }
 
   /**
@@ -151,23 +268,26 @@ export function createHealthProbe(session, opts = {}) {
    */
   async function probeL2() {
     if (!config.enableL2) {
-      status.l2 = 'skip';
-      return 'skip';
+      status.l2 = "skip";
+      return "skip";
     }
-    if (typeof config.checkMcp !== 'function') {
-      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)
+          setTimeout(
+            () => reject(new Error("probe_timeout")),
+            config.probeTimeoutMs,
+          ),
         ),
       ]);
-      status.l2 = connected ? 'ok' : 'fail';
+      status.l2 = connected ? "ok" : "fail";
     } catch {
-      status.l2 = 'fail';
+      status.l2 = "fail";
     }
     return status.l2;
   }
@@ -178,24 +298,25 @@ export function createHealthProbe(session, opts = {}) {
    */
   function probeL3() {
     if (promptAcked) {
-      status.l3 = 'ok';
-      return 'ok';
+      status.l3 = "ok";
+      return "ok";
     }
 
-    const currentBytes = typeof session.getOutputBytes === 'function'
-      ? session.getOutputBytes()
-      : 0;
+    const currentBytes =
+      typeof session.getOutputBytes === "function"
+        ? session.getOutputBytes()
+        : 0;
 
     if (currentBytes > 0) {
       promptAcked = true;
-      status.l3 = 'ok';
-      return 'ok';
+      status.l3 = "ok";
+      return "ok";
     }
 
     const elapsed = Date.now() - spawnedAt;
     if (elapsed >= config.l3ThresholdMs) {
-      status.l3 = 'timeout';
-      return 'timeout';
+      status.l3 = "timeout";
+      return "timeout";
     }
 
     status.l3 = null; // 아직 판정 전
@@ -204,35 +325,52 @@ export function createHealthProbe(session, opts = {}) {
 
   /**
    * 전체 probe 실행 (L0→L1→L2→L3).
-   * @returns {Promise<object>} probe 결과
+   * @returns {Promise<object|null>} probe 결과. stop() 이후 호출이면 null.
    */
   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);
-    }
+    if (stopped) return null;
+    // P0 (#167): probe 시작 시 epoch 캡처. start() 가 새 epoch 로 바꾸면 이 probe 의
+    // writeState 는 stale 로 판정 → skip.
+    const probeEpoch = runEpoch;
+    const promise = (async () => {
+      const result = {
+        l0: probeL0(),
+        l1: probeL1(),
+        l2: await probeL2(),
+        l3: probeL3(),
+        inputWaitPattern: status.inputWaitPattern,
+        ts: Date.now(),
+      };
+      status.lastProbeAt = result.ts;
+      writeState(result, probeEpoch);
+
+      if (typeof config.onProbe === "function") {
+        config.onProbe(result);
+      }
 
-    return result;
+      return result;
+    })();
+    // P1-1 (#167): Set 으로 모든 in-flight 추적. 단일 var 패턴은 N+1 이 N 끝나기 전에
+    // 시작되면 N 을 덮어써 stopAndDrain() 시 N 이 누락된다.
+    inFlightProbes.add(promise);
+    promise.finally(() => inFlightProbes.delete(promise));
+    return promise;
   }
 
   function start() {
     if (started) return;
     started = true;
+    stopped = false;
+    // P0 (#167): epoch 증가 — 이전 run 의 in-flight probe 가 새 run 의 state 를 덮지 못하게.
+    runEpoch += 1;
     spawnedAt = Date.now();
     lastOutputChangeAt = Date.now();
     lastOutputBytes = 0;
     promptAcked = false;
 
-    timer = setInterval(() => { void probe(); }, config.intervalMs);
+    timer = setInterval(() => {
+      void probe();
+    }, config.intervalMs);
     timer.unref?.();
 
     // 즉시 첫 probe 실행
@@ -242,10 +380,32 @@ export function createHealthProbe(session, opts = {}) {
   function stop() {
     if (!started) return;
     started = false;
+    // stopped 를 먼저 set 해야 in-flight probe()의 writeState() 가 skip 된다.
+    // 이후 unlink — in-flight 가 끝나도 writeState 가 no-op 이므로 재생성 없음.
+    stopped = true;
     if (timer) {
       clearInterval(timer);
       timer = null;
     }
+    if (config.writeStateFile || config.stateFile) {
+      try {
+        const stateFile = getStateFilePath();
+        if (stateFile) unlinkSync(stateFile);
+      } catch {}
+    }
+  }
+
+  /**
+   * stop() 후 in-flight probe() 가 완료될 때까지 대기.
+   * 결정적 종료가 필요한 테스트/teardown 용. conductor 의 sync stop() 호출자는
+   * 그대로 stop() 만 호출하면 stopped flag 가 race 를 막는다.
+   */
+  async function stopAndDrain() {
+    stop();
+    // P1-1 (#167): 모든 in-flight probe 대기. allSettled 로 unhandled rejection 방지.
+    if (inFlightProbes.size > 0) {
+      await Promise.allSettled(Array.from(inFlightProbes));
+    }
   }
 
   /** L1 tracking 리셋 (restart 후 호출) */
@@ -264,9 +424,12 @@ export function createHealthProbe(session, opts = {}) {
   return Object.freeze({
     start,
     stop,
+    stopAndDrain,
     probe,
     resetTracking,
     getStatus: () => ({ ...status }),
-    get started() { return started; },
+    get started() {
+      return started;
+    },
   });
 }

package/hub/team/interactive-native-launcher.mjs

@@ -0,0 +1,106 @@
+import crypto from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+
+import {
+  buildNativeWorkerRosterEntry,
+  deriveClaudeDaemonPaths,
+  mergeRosterWorkers,
+  removeRosterWorkers,
+} from "./claude-native-bridge.mjs";
+import { startInteractiveNativeWorker } from "./interactive-native-worker.mjs";
+
+function buildWorkerSocketPaths({ configDir, sessionName, pid, short }) {
+  const hash = crypto
+    .createHash("sha256")
+    .update(`${configDir || ""}:${sessionName}:${pid}:${crypto.randomUUID()}`)
+    .digest("hex")
+    .slice(0, 10);
+  const socketRoot = path.join(os.tmpdir(), `tfx-in-${hash}`);
+  return {
+    rvSock: path.join(socketRoot, `${short}.rv.sock`),
+    ptySock: path.join(socketRoot, `${short}.pty.sock`),
+  };
+}
+
+export async function launchAdoptedInteractiveWorker({
+  cwd = process.cwd(),
+  sessionName,
+  launchCmd = "codex",
+  cli = "codex",
+  role = "interactive",
+  configDir,
+  pid = process.pid,
+  _deps = {},
+} = {}) {
+  const startWorker =
+    _deps.startInteractiveNativeWorker || startInteractiveNativeWorker;
+  const buildRosterEntry =
+    _deps.buildNativeWorkerRosterEntry || buildNativeWorkerRosterEntry;
+  const mergeWorkers = _deps.mergeRosterWorkers || mergeRosterWorkers;
+  const derivePaths = _deps.deriveClaudeDaemonPaths || deriveClaudeDaemonPaths;
+
+  const resolvedCwd = path.resolve(cwd);
+  const effectiveSessionName =
+    sessionName || `tfx-${cli}-${role}-${process.pid}`;
+  const paths = derivePaths({ configDir });
+  const short = crypto.randomUUID().replaceAll("-", "").slice(0, 8);
+  const { rvSock, ptySock } = buildWorkerSocketPaths({
+    configDir,
+    sessionName: effectiveSessionName,
+    pid,
+    short,
+  });
+  const displayName = `Triflux ${cli} ${role}`;
+
+  let worker;
+  let closed = false;
+  let closePromise = null;
+
+  try {
+    worker = await startWorker({
+      short,
+      rvSock,
+      ptySock,
+      sessionName: effectiveSessionName,
+      cwd: resolvedCwd,
+      launchCmd,
+      pid,
+    });
+    const workerShort = worker.short || short;
+    const workerPid = worker.pid || pid;
+    const entry = buildRosterEntry({
+      short: workerShort,
+      pid: workerPid,
+      cwd: resolvedCwd,
+      rendezvousSock: worker.rvSock,
+      ptySock: worker.ptySock,
+      name: displayName,
+      prompt: displayName,
+    });
+    await mergeWorkers(paths.rosterPath, { [workerShort]: entry });
+
+    return {
+      short: workerShort,
+      displayName,
+      rosterPath: paths.rosterPath,
+      close() {
+        if (!closePromise) {
+          closePromise = (async () => {
+            if (closed) return;
+            closed = true;
+            try {
+              await worker.close();
+            } finally {
+              await removeRosterWorkers(paths.rosterPath, [workerShort]);
+            }
+          })();
+        }
+        return closePromise;
+      },
+    };
+  } catch (error) {
+    if (worker) await worker.close().catch(() => {});
+    throw error;
+  }
+}

package/hub/team/interactive-native-worker.mjs

@@ -0,0 +1,80 @@
+import { startNativeWorkerFacade } from "./claude-native-bridge.mjs";
+import { createInteractiveTuiTransport } from "./interactive-tui-transport.mjs";
+
+// Output currently flows through capture-pane snapshots, so attach clients may
+// receive whole-screen refreshes rather than byte-accurate terminal deltas.
+export async function startInteractiveNativeWorker({
+  short,
+  rvSock,
+  ptySock,
+  sessionName,
+  cwd,
+  launchCmd,
+  pid = process.pid,
+  env = {},
+  createTransport = createInteractiveTuiTransport,
+} = {}) {
+  let facade = null;
+  let closePromise = null;
+
+  const transport = createTransport({
+    sessionName,
+    cwd,
+    launchCmd,
+    env,
+    onData(chunk) {
+      if (facade) facade.writeOutput(chunk);
+    },
+  });
+
+  async function close({ exitCode = 0, waitForPtyEnd = false } = {}) {
+    if (!closePromise) {
+      closePromise = (async () => {
+        await transport.stop().catch(() => {});
+        if (waitForPtyEnd) {
+          await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+        if (facade) await facade.close({ exitCode });
+      })();
+    }
+    return closePromise;
+  }
+
+  try {
+    facade = await startNativeWorkerFacade({
+      short,
+      rvSock,
+      ptySock,
+      pid,
+      workerType: "interactive",
+      onInput(payload) {
+        void Promise.resolve()
+          .then(() => transport.writeInput(payload))
+          .catch(() => {
+            void close({ exitCode: 1 }).catch(() => {});
+          });
+      },
+      onKill() {
+        void close({ waitForPtyEnd: true }).catch(() => {});
+      },
+    });
+  } catch (error) {
+    await transport.stop().catch(() => {});
+    throw error;
+  }
+
+  try {
+    await transport.start();
+  } catch (error) {
+    await close({ exitCode: 1 }).catch(() => {});
+    throw error;
+  }
+
+  return {
+    short,
+    rvSock,
+    ptySock,
+    pid,
+    close,
+  };
+}