triflux 10.9.12 → 10.9.13

package/hub/team/synapse-registry.mjs

@@ -0,0 +1,275 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+const DEFAULT_LOCAL_HEARTBEAT_INTERVAL_MS = 5_000;
+const DEFAULT_LOCAL_TIMEOUT_MS = 30_000;
+const DEFAULT_REMOTE_HEARTBEAT_INTERVAL_MS = 15_000;
+const DEFAULT_REMOTE_TIMEOUT_MS = 90_000;
+
+function normalizeSessionId(sessionId) {
+  if (sessionId == null) return "";
+  return String(sessionId).trim();
+}
+
+function cloneSession(session) {
+  return {
+    ...session,
+    dirtyFiles: Array.isArray(session.dirtyFiles) ? [...session.dirtyFiles] : [],
+  };
+}
+
+function sanitizeSession(raw, fallbackSessionId = "") {
+  const sessionId = normalizeSessionId(raw?.sessionId ?? fallbackSessionId);
+  if (!sessionId) return null;
+
+  return {
+    sessionId,
+    host: typeof raw?.host === "string" ? raw.host : "local",
+    worktreePath: typeof raw?.worktreePath === "string" ? raw.worktreePath : "",
+    branch: typeof raw?.branch === "string" ? raw.branch : "",
+    dirtyFiles: Array.isArray(raw?.dirtyFiles) ? [...raw.dirtyFiles] : [],
+    taskSummary: typeof raw?.taskSummary === "string" ? raw.taskSummary : "",
+    lastHeartbeat:
+      typeof raw?.lastHeartbeat === "number" ? raw.lastHeartbeat : Date.now(),
+    status:
+      raw?.status === "stale" || raw?.status === "expired"
+        ? raw.status
+        : "active",
+    isRemote: Boolean(raw?.isRemote),
+  };
+}
+
+export function createSynapseRegistry(opts = {}) {
+  const {
+    persistPath,
+    localHeartbeatIntervalMs = DEFAULT_LOCAL_HEARTBEAT_INTERVAL_MS,
+    localTimeoutMs = DEFAULT_LOCAL_TIMEOUT_MS,
+    remoteHeartbeatIntervalMs = DEFAULT_REMOTE_HEARTBEAT_INTERVAL_MS,
+    remoteTimeoutMs = DEFAULT_REMOTE_TIMEOUT_MS,
+  } = opts;
+
+  const sessions = new Map();
+  const monitors = new Map();
+  const staleCallbacks = new Set();
+  const removedCallbacks = new Set();
+
+  function now() {
+    return Date.now();
+  }
+
+  function intervalFor(session) {
+    return session.isRemote
+      ? remoteHeartbeatIntervalMs
+      : localHeartbeatIntervalMs;
+  }
+
+  function timeoutFor(session) {
+    return session.isRemote ? remoteTimeoutMs : localTimeoutMs;
+  }
+
+  function persist() {
+    if (!persistPath) return;
+    try {
+      mkdirSync(dirname(persistPath), { recursive: true });
+      const data = Object.fromEntries(
+        [...sessions].map(([k, v]) => [k, cloneSession(v)]),
+      );
+      writeFileSync(persistPath, JSON.stringify(data, null, 2), "utf8");
+    } catch {
+      /* best-effort */
+    }
+  }
+
+  function restore() {
+    if (!persistPath || !existsSync(persistPath)) return;
+    try {
+      const data = JSON.parse(readFileSync(persistPath, "utf8"));
+      for (const [sessionId, session] of Object.entries(data)) {
+        const sanitized = sanitizeSession(session, sessionId);
+        if (sanitized) sessions.set(sanitized.sessionId, sanitized);
+      }
+    } catch {
+      /* corrupted file — start fresh */
+    }
+  }
+
+  function stopMonitor(sessionId) {
+    const timer = monitors.get(sessionId);
+    if (!timer) return;
+    clearInterval(timer);
+    monitors.delete(sessionId);
+  }
+
+  function notifyStale(session) {
+    // TODO: emit synapse.session.stale via Hub deliveryEmitter
+    for (const callback of staleCallbacks) {
+      try {
+        callback(cloneSession(session));
+      } catch {
+        /* no-op */
+      }
+    }
+  }
+
+  function notifyRemoved(session) {
+    // TODO: emit synapse.session.removed via Hub deliveryEmitter
+    for (const callback of removedCallbacks) {
+      try {
+        callback(cloneSession(session));
+      } catch {
+        /* no-op */
+      }
+    }
+  }
+
+  function startMonitor(sessionId) {
+    stopMonitor(sessionId);
+
+    const session = sessions.get(sessionId);
+    if (!session) return;
+
+    const timer = setInterval(() => {
+      const current = sessions.get(sessionId);
+      if (!current) return;
+
+      const elapsedMs = now() - current.lastHeartbeat;
+      if (elapsedMs > timeoutFor(current) && current.status !== "stale") {
+        current.status = "stale";
+        notifyStale(current);
+      }
+    }, intervalFor(session));
+
+    if (typeof timer.unref === "function") timer.unref();
+    monitors.set(sessionId, timer);
+  }
+
+  restore();
+  for (const sessionId of sessions.keys()) {
+    startMonitor(sessionId);
+  }
+
+  function register(meta) {
+    const sessionId = normalizeSessionId(meta?.sessionId);
+    if (!sessionId || sessions.has(sessionId)) {
+      return { ok: false, sessionId };
+    }
+
+    const session = sanitizeSession(
+      {
+        ...meta,
+        sessionId,
+        status: "active",
+        lastHeartbeat: now(),
+      },
+      sessionId,
+    );
+
+    sessions.set(sessionId, session);
+    startMonitor(sessionId);
+    persist();
+
+    // TODO: emit synapse.session.started via Hub deliveryEmitter
+    return { ok: true, sessionId };
+  }
+
+  function unregister(sessionId) {
+    const normalized = normalizeSessionId(sessionId);
+    const session = sessions.get(normalized);
+    if (!session) return false;
+
+    stopMonitor(normalized);
+    sessions.delete(normalized);
+    persist();
+    notifyRemoved(session);
+    return true;
+  }
+
+  function heartbeat(sessionId, partialMeta = null) {
+    const normalized = normalizeSessionId(sessionId);
+    const session = sessions.get(normalized);
+    if (!session) return false;
+
+    const wasRemote = session.isRemote;
+
+    session.lastHeartbeat = now();
+    session.status = "active";
+
+    if (partialMeta && typeof partialMeta === "object") {
+      if (typeof partialMeta.host === "string") session.host = partialMeta.host;
+      if (typeof partialMeta.worktreePath === "string") {
+        session.worktreePath = partialMeta.worktreePath;
+      }
+      if (typeof partialMeta.branch === "string") session.branch = partialMeta.branch;
+      if (Array.isArray(partialMeta.dirtyFiles)) {
+        session.dirtyFiles = [...partialMeta.dirtyFiles];
+      }
+      if (typeof partialMeta.taskSummary === "string") {
+        session.taskSummary = partialMeta.taskSummary;
+      }
+      if (typeof partialMeta.isRemote === "boolean") {
+        session.isRemote = partialMeta.isRemote;
+      }
+    }
+
+    if (session.isRemote !== wasRemote) {
+      startMonitor(normalized);
+    }
+
+    persist();
+    // TODO: emit synapse.session.heartbeat via Hub deliveryEmitter
+    return true;
+  }
+
+  function getActive() {
+    return [...sessions.values()]
+      .filter((session) => session.status === "active")
+      .map((session) => cloneSession(session));
+  }
+
+  function getAll() {
+    return [...sessions.values()].map((session) => cloneSession(session));
+  }
+
+  function getSession(sessionId) {
+    const normalized = normalizeSessionId(sessionId);
+    if (!normalized) return null;
+    const session = sessions.get(normalized);
+    return session ? cloneSession(session) : null;
+  }
+
+  function onStale(callback) {
+    if (typeof callback !== "function") return;
+    staleCallbacks.add(callback);
+  }
+
+  function onRemoved(callback) {
+    if (typeof callback !== "function") return;
+    removedCallbacks.add(callback);
+  }
+
+  function snapshot() {
+    return {
+      sessions: getAll(),
+    };
+  }
+
+  function destroy() {
+    for (const sessionId of monitors.keys()) {
+      stopMonitor(sessionId);
+    }
+    persist();
+  }
+
+  return Object.freeze({
+    register,
+    unregister,
+    heartbeat,
+    getActive,
+    getAll,
+    getSession,
+    onStale,
+    onRemoved,
+    snapshot,
+    destroy,
+  });
+}

package/hub/team/worktree-lifecycle.mjs

@@ -170,17 +170,42 @@ export async function prepareIntegrationBranch({
  * Rebase a shard branch onto the integration branch.
  * Uses rebase + fast-forward only (no merge commits).
  *
+ * Synapse v1: when a `preflight` checker + `sessionContext` are provided,
+ * the rebase is pre-flighted against active sessions' dirty files/leases.
+ * Blocked rebases return `{ ok: false, preflight: decision }` without touching
+ * any branch. If preflight is omitted, behavior is unchanged.
+ *
  * @param {object} opts
  * @param {string} opts.shardBranch — the shard's branch name
  * @param {string} opts.integrationBranch — target integration branch
  * @param {string} [opts.rootDir=process.cwd()]
- * @returns {Promise<{ ok: boolean, headCommit?: string, error?: string }>}
+ * @param {{ checkRebase: Function } | null} [opts.preflight=null] — git-preflight instance
+ * @param {{ sessionId: string, workerId?: string } | null} [opts.sessionContext=null]
+ * @returns {Promise<{ ok: boolean, headCommit?: string, error?: string, preflight?: object }>}
  */
 export async function rebaseShardOntoIntegration({
   shardBranch,
   integrationBranch,
   rootDir = process.cwd(),
+  preflight = null,
+  sessionContext = null,
 }) {
+  // Synapse v1 pre-flight: bail out before mutating branches when another
+  // session claims overlapping files.
+  if (preflight && sessionContext) {
+    const decision = preflight.checkRebase(
+      { branch: integrationBranch },
+      sessionContext,
+    );
+    if (!decision.allowed) {
+      return {
+        ok: false,
+        error: `git-preflight blocked rebase: ${decision.reason || "overlap"}`,
+        preflight: decision,
+      };
+    }
+  }
+
   // Backup integration HEAD for rollback
   const backupCommit = await git(["rev-parse", integrationBranch], rootDir);
 
@@ -220,18 +245,40 @@ export async function rebaseShardOntoIntegration({
  * Remove a worktree and its branch.
  * Follows WT race-guard: sleep between operations.
  *
+ * Synapse v1: when `preflight` + `sessionContext` are provided, the removal
+ * is pre-flighted against active sessions — blocked if another session is
+ * still registered to this worktree path.
+ *
  * @param {object} opts
  * @param {string} opts.worktreePath
  * @param {string} [opts.branchName] — optional branch to delete
  * @param {string} [opts.rootDir=process.cwd()]
  * @param {boolean} [opts.force=false]
+ * @param {{ checkWorktreeRemove: Function } | null} [opts.preflight=null]
+ * @param {{ sessionId: string, workerId?: string } | null} [opts.sessionContext=null]
  */
 export async function pruneWorktree({
   worktreePath,
   branchName,
   rootDir = process.cwd(),
   force = false,
+  preflight = null,
+  sessionContext = null,
 }) {
+  if (preflight && sessionContext) {
+    const decision = preflight.checkWorktreeRemove(
+      { worktreePath },
+      sessionContext,
+    );
+    if (!decision.allowed) {
+      return {
+        ok: false,
+        error: `git-preflight blocked worktree-remove: ${decision.reason || "active_worktree"}`,
+        preflight: decision,
+      };
+    }
+  }
+
   const forceFlag = force ? "--force" : "";
 
   // Remove worktree (with retry for Windows file handle issues — E5)

package/hub/workers/gemini-worker.mjs

@@ -349,7 +349,11 @@ export class GeminiWorker {
     }
 
     if (exitCode !== 0) {
-      throw createWorkerError(`Gemini worker exited with code ${exitCode}`, {
+      // Build a descriptive message when stderr is empty to aid debugging
+      const errMsg = result.stderr
+        ? `Gemini worker exited with code ${exitCode}`
+        : `Gemini worker exited with code ${exitCode} (stderr empty, signal=${exitSignal ?? "none"}, events=${events.length}, stdout=${result.stdout.length}B)`;
+      throw createWorkerError(errMsg, {
         code: "WORKER_EXIT",
         result,
         stderr: result.stderr,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.9.12",
+  "version": "10.9.13",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "type": "module",
   "bin": {

package/scripts/__tests__/tfx-doctor-diagnose.test.mjs

@@ -39,6 +39,15 @@ describe("doctor-diagnose: 진단 번들 생성", () => {
     assert.equal(typeof result.hookTimingCount, "number");
   });
 
+  it("codexMcpApproval 진단 결과 포함", () => {
+    assert.ok(result.codexMcpApproval, "codexMcpApproval 필드 누락");
+    assert.equal(typeof result.codexMcpApproval.found, "boolean");
+    if (result.codexMcpApproval.found) {
+      assert.ok(Array.isArray(result.codexMcpApproval.tools));
+      assert.ok(result.codexMcpApproval.tools.length > 0);
+    }
+  });
+
   after(() => {
     // 테스트 생성 zip 정리
     if (result?.zipPath && existsSync(result.zipPath)) {

package/scripts/doctor-diagnose.mjs

@@ -18,6 +18,7 @@ import { join } from "node:path";
 const TRIFLUX_DIR = join(homedir(), ".triflux");
 const LOGS_DIR = join(TRIFLUX_DIR, "logs");
 const DIAG_DIR = join(TRIFLUX_DIR, "diagnostics");
+const CODEX_CONFIG_PATH = join(homedir(), ".codex", "config.toml");
 const ONE_HOUR_MS = 60 * 60 * 1000;
 
 function collectSpawnTraces(cutoffMs = ONE_HOUR_MS) {
@@ -85,6 +86,47 @@ function computeSpawnStats(traces) {
   };
 }
 
+/**
+ * ~/.codex/config.toml에서 [mcp_servers.*.tools.*] 섹션 내부의
+ * approval_mode = "approve"를 감지한다. 이 값이 있으면 codex exec가
+ * non-TTY subprocess에서 승인 대기로 stall한다.
+ * refs: tellang/triflux#66, Yeachan-Heo/oh-my-codex#1478
+ */
+function checkCodexMcpApproval() {
+  if (!existsSync(CODEX_CONFIG_PATH)) {
+    return { found: false, reason: "config.toml not found" };
+  }
+
+  let content;
+  try {
+    content = readFileSync(CODEX_CONFIG_PATH, "utf8");
+  } catch {
+    return { found: false, reason: "config.toml unreadable" };
+  }
+
+  const badTools = [];
+  let inMcpTool = false;
+  let currentSection = "";
+
+  for (const line of content.split("\n")) {
+    const sectionMatch = line.match(/^\[(.+)\]/);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1];
+      inMcpTool = /^mcp_servers\..+\.tools\./.test(currentSection);
+      continue;
+    }
+    if (inMcpTool && /^\s*approval_mode\s*=\s*"approve"/.test(line)) {
+      badTools.push(currentSection);
+    }
+  }
+
+  return {
+    found: badTools.length > 0,
+    tools: badTools,
+    fix: 'sed -i \'s/approval_mode = "approve"/approval_mode = "auto"/g\' ~/.codex/config.toml',
+  };
+}
+
 function collectSystemInfo() {
   const info = {
     platform: platform(),
@@ -165,9 +207,28 @@ function generateSummary(stats, sysInfo, hookTimings, traceCount) {
     `blocked:           ${stats.blocked}`,
     `trace entries:     ${traceCount}`,
     "",
-    "--- Hook Timings (last 1h) ---",
+    "--- Codex MCP Approval Check ---",
   ];
 
+  const mcpCheck = checkCodexMcpApproval();
+  if (!mcpCheck.found && mcpCheck.reason) {
+    lines.push(`  ${mcpCheck.reason}`);
+  } else if (mcpCheck.found) {
+    lines.push(`  ⚠ ${mcpCheck.tools.length}개 MCP tool에 approval_mode="approve" 감지`);
+    lines.push(`    codex exec non-TTY stall 위험 (refs: triflux#66)`);
+    for (const tool of mcpCheck.tools) {
+      lines.push(`    - [${tool}]`);
+    }
+    lines.push(`    fix: ${mcpCheck.fix}`);
+  } else {
+    lines.push("  ✔ MCP tool approval_mode 정상");
+  }
+
+  lines.push(
+    "",
+    "--- Hook Timings (last 1h) ---",
+  );
+
   if (hookTimings.length === 0) {
     lines.push("no hook timing data found");
   } else {
@@ -248,6 +309,8 @@ export async function diagnose({ json = false } = {}) {
     rmSync(bundleDir, { recursive: true, force: true });
   } catch { /* leave it */ }
 
+  const mcpApprovalCheck = checkCodexMcpApproval();
+
   const result = {
     ok: true,
     zipPath,
@@ -255,6 +318,7 @@ export async function diagnose({ json = false } = {}) {
     sysInfo,
     traceCount: traces.length,
     hookTimingCount: hookTimings.length,
+    codexMcpApproval: mcpApprovalCheck,
   };
 
   if (json) {

package/scripts/headless-guard.mjs

@@ -30,6 +30,7 @@ import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { deny, nudge } from "./lib/hook-utils.mjs";
+import { isProcessAlive } from "./lib/process-utils.mjs";
 import { probePsmuxSupport } from "./lib/psmux-info.mjs";
 
 const CACHE_FILE = join(tmpdir(), "tfx-psmux-check.json");
@@ -41,16 +42,6 @@ const MULTI_EXPIRE_MS = 30 * 60 * 1000; // 30분 자동 만료
 const GATE_THRESHOLD = 2; // A: dispatch 전 허용할 Agent 호출 수
 const NUDGE_THRESHOLD = 4; // B: dispatch 후 nudge 트리거 횟수
 
-function isOwnerAlive(pid) {
-  if (!pid || typeof pid !== "number") return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 function readMultiState() {
   try {
     if (!existsSync(MULTI_STATE_FILE)) return null;
@@ -66,7 +57,7 @@ function readMultiState() {
       return null;
     }
     // ownerPid 생존 체크 — 소유 세션이 죽었으면 stale (#62)
-    if (state.ownerPid && !isOwnerAlive(state.ownerPid)) {
+    if (state.ownerPid && !isProcessAlive(state.ownerPid)) {
       try {
         unlinkSync(MULTI_STATE_FILE);
       } catch {

package/scripts/lib/process-utils.mjs

@@ -0,0 +1,26 @@
+// scripts/lib/process-utils.mjs
+// 프로세스 관련 공유 유틸리티 (훅 및 lightweight 스크립트용)
+//
+// Note: hub/lib/process-utils.mjs에는 더 포괄적인 orphan cleanup 로직이 있습니다.
+// 이 파일은 단순 alive 체크만 필요한 훅/스크립트용 (상위 의존성 없이 동작).
+
+/**
+ * 주어진 PID의 프로세스가 살아있는지 확인합니다.
+ * - EPERM: 프로세스는 존재하지만 signal 권한 없음 → alive
+ * - ESRCH: 프로세스가 존재하지 않음 → dead
+ * - 기타 에러 (invalid pid 포함): dead로 간주
+ *
+ * @param {number|string} pid
+ * @returns {boolean}
+ */
+export function isProcessAlive(pid) {
+  const n = Number(pid);
+  if (!Number.isInteger(n) || n <= 0) return false;
+  try {
+    process.kill(n, 0);
+    return true;
+  } catch (e) {
+    if (e?.code === "EPERM") return true;
+    return false;
+  }
+}

package/scripts/session-stale-cleanup.mjs

@@ -20,20 +20,12 @@ import {
 } from "node:fs";
 import { platform, tmpdir } from "node:os";
 import { join } from "node:path";
+import { isProcessAlive } from "./lib/process-utils.mjs";
 
 const MULTI_STATE_FILE = join(tmpdir(), "tfx-multi-state.json");
 const EXPIRE_MS = 30 * 60 * 1000; // 30분
 const PID_FILE_RE = /^tfx-route-(\d+)-pids$/;
 
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 function treeKill(pid) {
   try {
     if (platform() === "win32") {

package/scripts/tfx-route-worker.mjs

@@ -222,11 +222,31 @@ try {
     if (!result.response.endsWith("\n")) process.stdout.write("\n");
   }
 } catch (error) {
+  // Always emit error.message first for quick identification
+  process.stderr.write(`[tfx-route-worker] ${error.message}\n`);
+
+  // Emit captured stderr from the child process (may be empty)
   if (error.stderr) {
     process.stderr.write(String(error.stderr));
     if (!String(error.stderr).endsWith("\n")) process.stderr.write("\n");
   }
-  process.stderr.write(`${error.message}\n`);
+
+  // When stderr is empty, surface diagnostic details from error.result
+  // so the caller can debug silent failures
+  if (!error.stderr && error.result) {
+    const r = error.result;
+    const diag = [
+      `[tfx-route-worker] diagnostics: exitCode=${r.exitCode ?? "null"} signal=${r.exitSignal ?? "none"} timedOut=${r.timedOut ?? false}`,
+      r.events?.length
+        ? `[tfx-route-worker] events(${r.events.length}): ${JSON.stringify(r.events.slice(-3))}`
+        : "[tfx-route-worker] events: none",
+      r.stdout
+        ? `[tfx-route-worker] child stdout(${r.stdout.length}B): ${r.stdout.slice(0, 512)}`
+        : "[tfx-route-worker] child stdout: empty",
+    ];
+    process.stderr.write(diag.join("\n") + "\n");
+  }
+
   process.exitCode = error.code === "ETIMEDOUT" ? 124 : 1;
 } finally {
   try {