@triflux/remote 10.30.1 → 10.32.0

package/hub/server.mjs

@@ -56,6 +56,7 @@ import { createStoreAdapter } from "./store-adapter.mjs";
 import { createGitPreflight } from "./team/git-preflight.mjs";
 import { nativeProxy } from "./team/nativeProxy.mjs";
 import { createSwarmLocks } from "./team/swarm-locks.mjs";
+import { createCtoAutoCollector } from "./team/cto-auto-collect.mjs";
 import {
   createSynapseRegistry,
   projectPeer,
@@ -69,6 +70,21 @@ registerTeamBridge(nativeProxy);
 const hubLog = createModuleLogger("hub");
 const brokerDiagnosticsAttached = new WeakSet();
 
+async function runCtoCollect(args, opts) {
+  try {
+    const mod = await import("triflux/cto/collect.mjs");
+    if (typeof mod?.runCollect === "function") {
+      return await mod.runCollect(args, opts);
+    }
+  } catch (error) {
+    hubLog.warn(
+      { err: String(error?.message || error) },
+      "cto.auto_collect.remote_collect_unavailable",
+    );
+  }
+  return null;
+}
+
 const MAX_BODY_SIZE = 1024 * 1024;
 const PUBLIC_PATHS = new Set(["/", "/status", "/health", "/healthz"]);
 const RATE_LIMIT_MAX = 100; // requests per window
@@ -1009,10 +1025,16 @@ export async function startHub({
     registry: synapseRegistry,
     locks: swarmLocks,
   });
+  const ctoAutoCollector = createCtoAutoCollector({
+    registry: synapseRegistry,
+    runCollect: runCtoCollect,
+    logger: hubLog,
+  });
 
   // Synapse Layer 5: emitter subscribers — bridge events to hub logging
-  synapseEmitter.on("synapse.session.started", ({ sessionId }) => {
+  synapseEmitter.on("synapse.session.started", ({ sessionId, session }) => {
     hubLog.info({ sessionId }, "synapse.session.started");
+    ctoAutoCollector.handleSessionStarted({ sessionId, session });
   });
   synapseEmitter.on("synapse.session.heartbeat", ({ sessionId }) => {
     hubLog.debug({ sessionId }, "synapse.session.heartbeat");
@@ -2054,6 +2076,16 @@ export async function startHub({
   }, 60000);
   sessionTimer.unref();
 
+  const synapsePruneTimer = setInterval(() => {
+    try {
+      const { count } = synapseRegistry.pruneExpired();
+      if (count > 0) hubLog.info({ count }, "synapse.prune");
+    } catch (err) {
+      hubLog.warn({ err }, "synapse.prune_failed");
+    }
+  }, 60000);
+  synapsePruneTimer.unref();
+
   // 고아 node.exe 프로세스 + stale spawn 세션 주기적 정리 (5분마다)
   // TFX_DISABLE_ORPHAN_CLEANUP=1 로 비활성 (active SSH/swarm 세션 보호 회피용 hotfix gate)
   const orphanCleanupTimer = setInterval(
@@ -2288,6 +2320,7 @@ export async function startHub({
               router.stopSweeper();
               clearInterval(hitlTimer);
               clearInterval(sessionTimer);
+              clearInterval(synapsePruneTimer);
               clearInterval(rateLimitTimer);
               clearInterval(orphanCleanupTimer);
               if (idleTimer) {

package/hub/team/cto-auto-collect.mjs

@@ -0,0 +1,109 @@
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+const DEFAULT_DEBOUNCE_MS = 120_000;
+const OFF_VALUES = new Set(["0", "false", "off", "no"]);
+
+export function isCtoAutoCollectDisabled(env = process.env) {
+  return OFF_VALUES.has(
+    String(env?.TFX_CTO_AUTO_COLLECT ?? "")
+      .trim()
+      .toLowerCase(),
+  );
+}
+
+function freshCurrentMd(projectRoot, now, debounceMs) {
+  try {
+    const currentMd = join(projectRoot, ".triflux", "lake", "current.md");
+    if (!existsSync(currentMd)) return false;
+    return now - statSync(currentMd).mtimeMs < debounceMs;
+  } catch {
+    return false;
+  }
+}
+
+export function createCtoAutoCollector(opts = {}) {
+  const registry = opts.registry;
+  const runCollect = opts.runCollect;
+  const logger = opts.logger || null;
+  const debounceMs = Number(opts.debounceMs || DEFAULT_DEBOUNCE_MS);
+  const now = opts.now || (() => Date.now());
+  const env = opts.env || process.env;
+  const lastCollectMs = opts.lastCollectMs || new Map();
+  const inFlight = new Set();
+
+  function handleSessionStarted({ sessionId, session } = {}) {
+    if (isCtoAutoCollectDisabled(env))
+      return { triggered: false, reason: "disabled" };
+    if (!registry || typeof registry.querySessions !== "function") {
+      return { triggered: false, reason: "missing-registry" };
+    }
+    if (typeof runCollect !== "function") {
+      return { triggered: false, reason: "missing-runCollect" };
+    }
+
+    const cwd = typeof session?.cwd === "string" ? session.cwd : "";
+    const worktree =
+      typeof session?.worktreePath === "string" ? session.worktreePath : "";
+    const projectRoot = worktree || cwd;
+    if (!projectRoot)
+      return { triggered: false, reason: "missing-project-root" };
+
+    let peers = [];
+    try {
+      peers = registry.querySessions({
+        cwd,
+        worktree,
+        excludeSessionId: sessionId,
+      });
+    } catch (error) {
+      logger?.warn?.(
+        { sessionId, err: String(error?.message || error) },
+        "cto.auto_collect.query_failed",
+      );
+      return { triggered: false, reason: "query-failed" };
+    }
+    if (!Array.isArray(peers) || peers.length < 1) {
+      return { triggered: false, reason: "no-peers" };
+    }
+
+    const currentTime = now();
+    const last = lastCollectMs.get(projectRoot) || 0;
+    if (currentTime - last < debounceMs) {
+      return { triggered: false, reason: "debounced" };
+    }
+    if (freshCurrentMd(projectRoot, currentTime, debounceMs)) {
+      lastCollectMs.set(projectRoot, currentTime);
+      return { triggered: false, reason: "fresh-lake" };
+    }
+
+    lastCollectMs.set(projectRoot, currentTime);
+    const promise = Promise.resolve()
+      .then(() => runCollect([], { rootDir: projectRoot }))
+      .catch((error) => {
+        logger?.warn?.(
+          { projectRoot, err: String(error?.message || error) },
+          "cto.auto_collect.failed",
+        );
+      })
+      .finally(() => {
+        inFlight.delete(promise);
+      });
+    inFlight.add(promise);
+    return {
+      triggered: true,
+      reason: "triggered",
+      projectRoot,
+      peerCount: peers.length,
+    };
+  }
+
+  async function drain() {
+    await Promise.allSettled([...inFlight]);
+  }
+
+  return Object.freeze({
+    handleSessionStarted,
+    drain,
+  });
+}

package/hub/team/synapse-registry.mjs

@@ -5,6 +5,7 @@ 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;
+const DEFAULT_EXPIRE_TIMEOUT_MS = 24 * 60 * 60 * 1000;
 // Interactive (Claude/Codex) sessions idle for long stretches; a 30s local
 // timeout produces stale false-positives. 5-minute TTL + an `idle` state
 // distinguishes "alive but inactive" from "presumed dead".
@@ -133,6 +134,7 @@ export function createSynapseRegistry(opts = {}) {
     remoteTimeoutMs = DEFAULT_REMOTE_TIMEOUT_MS,
     interactiveHeartbeatIntervalMs = DEFAULT_INTERACTIVE_HEARTBEAT_INTERVAL_MS,
     interactiveTimeoutMs = DEFAULT_INTERACTIVE_TIMEOUT_MS,
+    expireTimeoutMs = DEFAULT_EXPIRE_TIMEOUT_MS,
   } = opts;
 
   const sessions = new Map();
@@ -355,10 +357,89 @@ export function createSynapseRegistry(opts = {}) {
     return true;
   }
 
+  // stale/expired 세션이 expireTimeoutMs 넘게 누적되면 Map에서 제거.
+  // live(active/idle)는 lastHeartbeat가 오래돼도 보존 — git-preflight dirty-file 가드가 의존.
+  function pruneExpired(opts2 = {}) {
+    if (destroyed) return { removed: [], count: 0 };
+
+    const cutoff =
+      typeof opts2.olderThanMs === "number"
+        ? opts2.olderThanMs
+        : expireTimeoutMs;
+    const removed = [];
+    const currentTime = now();
+
+    for (const [sessionId, session] of sessions) {
+      if (
+        isLiveStatus(session.status) ||
+        currentTime - session.lastHeartbeat <= cutoff
+      ) {
+        continue;
+      }
+
+      stopMonitor(sessionId);
+      sessions.delete(sessionId);
+      removed.push(sessionId);
+      notifyRemoved(session);
+    }
+
+    if (removed.length > 0) persist();
+    return { removed, count: removed.length };
+  }
+
   function heartbeat(sessionId, partialMeta = null) {
     const normalized = normalizeSessionId(sessionId);
     const session = sessions.get(normalized);
-    if (!session) return false;
+    if (!session) {
+      // self-heal은 위치 정보(worktreePath 또는 cwd)가 있는 heartbeat에서만
+      // 발동한다. UserPromptSubmit heartbeat는 항상 worktreePath를 보내므로
+      // SessionStart register POST drop 복구 경로는 커버되고, taskSummary만 담은
+      // 빈약한 heartbeat로 위치 없는 가비지 세션이 register 되는 것은 막는다
+      // (그 경우는 기존대로 false → 400/heartbeat failed).
+      const hasLocator =
+        partialMeta &&
+        typeof partialMeta === "object" &&
+        !Array.isArray(partialMeta) &&
+        ((typeof partialMeta.worktreePath === "string" &&
+          partialMeta.worktreePath.length > 0) ||
+          (typeof partialMeta.cwd === "string" && partialMeta.cwd.length > 0));
+      const canSelfHeal = Boolean(normalized) && hasLocator;
+      if (!canSelfHeal) return false;
+
+      // 미등록 세션 heartbeat = SessionStart register POST가 drop된 경우.
+      // self-heal로 register 복구(영구 미등록 방지).
+      //
+      // sessionKind는 명시값이 없으면 "interactive"로 본다. 실제 복구 경로인
+      // heartbeatInteractiveSession은 worktreePath/host/taskSummary만 보내고
+      // sessionKind는 생략하는데, sanitizeSession 기본값("headless")으로 떨어지면
+      // 복구된 Claude 세션이 30초 local timeout을 받아 idle/5분 TTL을 잃고 곧장
+      // stale로 전이돼 getActive()/peer discovery에서 사라진다(이 PRD가 고치려던
+      // 원래 증상의 재현). heartbeat 기반 liveness로 살아나는 세션은 interactive다.
+      const sanitizedKind =
+        typeof partialMeta.sessionKind === "string"
+          ? partialMeta.sessionKind
+          : "interactive";
+      const healed = sanitizeSession(
+        {
+          ...partialMeta,
+          sessionId: normalized,
+          sessionKind: sanitizedKind,
+          status: "active",
+          lastHeartbeat: now(),
+        },
+        normalized,
+      );
+      if (!healed) return false;
+
+      sessions.set(normalized, healed);
+      startMonitor(normalized);
+      persist();
+      emitter?.emit("synapse.session.started", {
+        sessionId: normalized,
+        session: cloneSession(healed),
+      });
+      return true;
+    }
 
     const wasRemote = session.isRemote;
     const updated = { ...session, lastHeartbeat: now(), status: "active" };
@@ -492,6 +573,7 @@ export function createSynapseRegistry(opts = {}) {
   return Object.freeze({
     register,
     unregister,
+    pruneExpired,
     heartbeat,
     getActive,
     getAll,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/remote",
-  "version": "10.30.1",
+  "version": "10.32.0",
   "description": "triflux remote — team mode, psmux, MCP workers, SQLite store.",
   "type": "module",
   "main": "hub/index.mjs",