@triflux/remote 10.51.0 → 10.53.0

package/hub/team/cli/services/hub-client.mjs

@@ -1,178 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import { publishLeadControl as publishLeadControlBridge } from "../../lead-control.mjs";
-import {
-  getTeamStatus as fetchTeamStatus,
-  subscribeToLeadCommands as pullLeadCommands,
-} from "../../session-sync.mjs";
-import { HUB_PID_DIR } from "./state-store.mjs";
-
-const HUB_PID_FILE = join(HUB_PID_DIR, "hub.pid");
-const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "::1"]);
-
-export function formatHostForUrl(host) {
-  return host.includes(":") ? `[${host}]` : host;
-}
-
-export function buildHubBaseUrl(host, port) {
-  return `http://${formatHostForUrl(host)}:${port}`;
-}
-
-export function getDefaultHubPort() {
-  const envPortRaw = Number(process.env.TFX_HUB_PORT || "27888");
-  return Number.isFinite(envPortRaw) && envPortRaw > 0 ? envPortRaw : 27888;
-}
-
-export function getDefaultHubUrl() {
-  return `${buildHubBaseUrl("127.0.0.1", getDefaultHubPort())}/mcp`;
-}
-
-function normalizeLoopbackHost(host) {
-  if (typeof host !== "string") return "127.0.0.1";
-  const candidate = host.trim();
-  return LOOPBACK_HOSTS.has(candidate) ? candidate : "127.0.0.1";
-}
-
-async function probeHubStatus(host, port, timeoutMs = 1500) {
-  try {
-    const res = await fetch(`${buildHubBaseUrl(host, port)}/status`, {
-      signal: AbortSignal.timeout(timeoutMs),
-    });
-    if (!res.ok) return null;
-    const data = await res.json();
-    return data?.hub ? data : null;
-  } catch {
-    return null;
-  }
-}
-
-export async function getHubInfo() {
-  const probePort = getDefaultHubPort();
-
-  if (existsSync(HUB_PID_FILE)) {
-    try {
-      const raw = JSON.parse(readFileSync(HUB_PID_FILE, "utf8"));
-      const pid = Number(raw?.pid);
-      if (!Number.isFinite(pid) || pid <= 0) throw new Error("invalid pid");
-      process.kill(pid, 0);
-      const host = normalizeLoopbackHost(raw?.host);
-      const port = Number(raw?.port) || probePort;
-      const status = await probeHubStatus(host, port, 1200);
-      if (!status) throw new Error("pid file process is not a healthy hub");
-      return {
-        ...raw,
-        pid,
-        host,
-        port,
-        url: `${buildHubBaseUrl(host, port)}/mcp`,
-      };
-    } catch {
-      try {
-        unlinkSync(HUB_PID_FILE);
-      } catch {}
-    }
-  }
-
-  for (const portCandidate of Array.from(new Set([probePort, 27888]))) {
-    const data = await probeHubStatus("127.0.0.1", portCandidate, 1200);
-    if (!data) continue;
-    const port = Number(data.port) || portCandidate;
-    const pid = Number(data.pid);
-    const recovered = {
-      pid: Number.isFinite(pid) ? pid : null,
-      host: "127.0.0.1",
-      port,
-      url: `${buildHubBaseUrl("127.0.0.1", port)}/mcp`,
-      discovered: true,
-    };
-    if (Number.isFinite(recovered.pid) && recovered.pid > 0) {
-      try {
-        mkdirSync(HUB_PID_DIR, { recursive: true });
-        writeFileSync(
-          HUB_PID_FILE,
-          JSON.stringify({ ...recovered, started: Date.now() }),
-        );
-      } catch {}
-    }
-    return recovered;
-  }
-  return null;
-}
-
-export async function fetchHubTaskList(state) {
-  const hubBase = (state?.hubUrl || getDefaultHubUrl()).replace(/\/mcp$/, "");
-  const teamName = state?.sessionName || null;
-  if (!teamName) return [];
-
-  try {
-    const res = await fetch(`${hubBase}/bridge/team/task-list`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ team_name: teamName }),
-      signal: AbortSignal.timeout(2000),
-    });
-    const data = await res.json();
-    return data?.ok ? data.data?.tasks || [] : [];
-  } catch {
-    return [];
-  }
-}
-
-export async function publishLeadControl(
-  state,
-  targetMember,
-  command,
-  reason = "",
-) {
-  const hubBase = (state?.hubUrl || getDefaultHubUrl()).replace(/\/mcp$/, "");
-  const leadAgent =
-    (state?.members || []).find((member) => member.role === "lead")?.agentId ||
-    "lead";
-  const targetAgent =
-    typeof targetMember === "string" ? targetMember : targetMember?.agentId;
-
-  const result = await publishLeadControlBridge({
-    hubUrl: hubBase,
-    fromAgent: leadAgent,
-    toAgent: targetAgent,
-    command,
-    reason,
-    payload: {
-      issued_by: leadAgent,
-      issued_at: Date.now(),
-    },
-  });
-
-  return !!result?.ok;
-}
-
-export async function subscribeToLeadCommands(state, member, options = {}) {
-  const hubBase = (state?.hubUrl || getDefaultHubUrl()).replace(/\/mcp$/, "");
-  const fallbackAgentId =
-    (state?.members || []).find((candidate) => candidate.role === "lead")
-      ?.agentId || null;
-  const agentId =
-    typeof member === "string"
-      ? member
-      : member?.agentId || options?.agentId || fallbackAgentId;
-
-  return await pullLeadCommands({
-    hubUrl: hubBase,
-    agentId,
-    ...options,
-  });
-}
-
-export async function getTeamStatus(state, options = {}) {
-  const hubBase = (state?.hubUrl || getDefaultHubUrl()).replace(/\/mcp$/, "");
-  return await fetchTeamStatus({
-    hubUrl: hubBase,
-    ...options,
-  });
-}

package/hub/team/conductor-registry.mjs

@@ -1,121 +0,0 @@
-function normalizeSessionId(sessionId) {
-  if (sessionId == null) return "";
-  return String(sessionId).trim();
-}
-
-export function createConductorRegistry() {
-  const sessions = new Map();
-
-  return Object.freeze({
-    register(sessionId, conductor) {
-      const normalizedSessionId = normalizeSessionId(sessionId);
-      if (
-        !normalizedSessionId ||
-        !conductor ||
-        typeof conductor.sendInput !== "function"
-      ) {
-        return false;
-      }
-      sessions.set(normalizedSessionId, conductor);
-      return true;
-    },
-
-    unregister(sessionId, conductor = null) {
-      const normalizedSessionId = normalizeSessionId(sessionId);
-      if (!normalizedSessionId || !sessions.has(normalizedSessionId))
-        return false;
-      if (conductor && sessions.get(normalizedSessionId) !== conductor)
-        return false;
-      return sessions.delete(normalizedSessionId);
-    },
-
-    get(sessionId) {
-      const normalizedSessionId = normalizeSessionId(sessionId);
-      if (!normalizedSessionId) return null;
-      return sessions.get(normalizedSessionId) || null;
-    },
-
-    clear() {
-      sessions.clear();
-    },
-
-    list() {
-      return [...sessions.keys()];
-    },
-  });
-}
-
-let conductorRegistry = null;
-
-export function getConductorRegistry() {
-  return conductorRegistry;
-}
-
-export function setConductorRegistry(nextRegistry) {
-  const previousRegistry = conductorRegistry;
-  conductorRegistry = nextRegistry ?? null;
-  return previousRegistry;
-}
-
-export function ensureConductorRegistry() {
-  if (!conductorRegistry) {
-    conductorRegistry = createConductorRegistry();
-  }
-  return conductorRegistry;
-}
-
-export function sendInputToConductorSession(sessionId, text) {
-  const normalizedSessionId = normalizeSessionId(sessionId);
-  const normalizedText = typeof text === "string" ? text : "";
-
-  if (!normalizedSessionId || !normalizedText) {
-    return {
-      ok: false,
-      error: {
-        code: "INVALID_SEND_INPUT",
-        message: "session_id, text 필수",
-      },
-    };
-  }
-
-  const registry = getConductorRegistry();
-  if (!registry) {
-    return {
-      ok: false,
-      error: {
-        code: "CONDUCTOR_REGISTRY_NOT_AVAILABLE",
-        message: "Conductor registry가 초기화되지 않았습니다",
-      },
-    };
-  }
-
-  const conductor = registry.get(normalizedSessionId);
-  if (!conductor) {
-    return {
-      ok: false,
-      error: {
-        code: "CONDUCTOR_SESSION_NOT_FOUND",
-        message: `Conductor session not found: ${normalizedSessionId}`,
-      },
-    };
-  }
-
-  const sent = conductor.sendInput(normalizedSessionId, normalizedText);
-  if (!sent) {
-    return {
-      ok: false,
-      error: {
-        code: "SEND_INPUT_FAILED",
-        message: `입력 전송 실패: ${normalizedSessionId}`,
-      },
-    };
-  }
-
-  return {
-    ok: true,
-    data: {
-      session_id: normalizedSessionId,
-      sent: true,
-    },
-  };
-}

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

@@ -1,115 +0,0 @@
-import { existsSync, statSync } from "node:fs";
-import { join } from "node:path";
-
-import { resolveLakeRootDir } from "../../cto/lake-root.mjs";
-import { resolveRoleControlSnapshot } from "../lib/cto-env.mjs";
-
-const DEFAULT_DEBOUNCE_MS = 120_000;
-
-export function isCtoAutoCollectDisabled(env = process.env) {
-  return !resolveRoleControlSnapshot(env).auto_collect_enabled;
-}
-
-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 = resolveLakeRootDir(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",
-      );
-      // peer 조회 실패는 collect 를 막지 않는다 — peer 정보는 이제 라벨 용도뿐이라
-      // registry 일시 장애에도 solo 로 진행해 collect 회복력을 유지한다.
-      peers = [];
-    }
-    // 단일 세션(peer 0개)도 허용한다 — 사용자 선택. peer 유무와 무관하게
-    // 아래 debounce + fresh-lake 게이트가 collect 빈도를 제어한다.
-    //
-    // 주의: peerCount 는 best-effort 라벨이다. querySessions 는 raw
-    // cwd/worktreePath 로 매칭하지만 projectRoot 는 resolved git toplevel 이라,
-    // 같은 repo 의 다른 하위 폴더 세션은 peer 로 안 잡혀 triggered-solo 로 보고될
-    // 수 있다. 즉 라벨은 repo-scoped 가 아니라 exact-cwd-scoped 다 — 향후 peer
-    // 기반 로직을 이 라벨 위에 다시 올릴 때 주의한다.
-    const peerCount = Array.isArray(peers) ? peers.length : 0;
-
-    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: peerCount > 0 ? "triggered" : "triggered-solo",
-      projectRoot,
-      peerCount,
-    };
-  }
-
-  async function drain() {
-    await Promise.allSettled([...inFlight]);
-  }
-
-  return Object.freeze({
-    handleSessionStarted,
-    drain,
-  });
-}

package/hub/team/lead-control.mjs

@@ -1,191 +0,0 @@
-import { readState } from "@triflux/core/hub/state.mjs";
-
-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 isPidAlive(pid) {
-  const resolvedPid = Number(pid);
-  if (!Number.isFinite(resolvedPid) || resolvedPid <= 0) return false;
-  try {
-    process.kill(resolvedPid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function resolveHeadlessHubUrl() {
-  const stateUrl = normalizeHubBaseUrl(readState()?.url);
-  if (stateUrl) return stateUrl;
-
-  const envHubUrl = normalizeHubBaseUrl(process.env.TFX_HUB_URL);
-  if (envHubUrl) return envHubUrl;
-
-  const envPort = Number(process.env.TFX_HUB_PORT || "27888");
-  const port = Number.isFinite(envPort) && envPort > 0 ? envPort : 27888;
-  return `http://127.0.0.1:${port}`;
-}
-
-function hasLiveHubState() {
-  const state = readState();
-  return !!normalizeHubBaseUrl(state?.url) && isPidAlive(state?.pid);
-}
-
-function toHeadlessSessionAgentId(sessionName) {
-  const normalizedSessionName = String(sessionName || "").trim();
-  return normalizedSessionName ? `session:${normalizedSessionName}` : "";
-}
-
-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,
-    };
-  }
-}
-
-export async function publishHeadlessControl(
-  sessionName,
-  command,
-  targetWorker = "*",
-) {
-  const sessionAgentId = toHeadlessSessionAgentId(sessionName);
-  if (!sessionAgentId) {
-    return {
-      ok: false,
-      noop: true,
-      error: "SESSION_NAME_REQUIRED",
-      command: String(command || "")
-        .trim()
-        .toLowerCase(),
-    };
-  }
-
-  if (!normalizeHubBaseUrl(process.env.TFX_HUB_URL) && !hasLiveHubState()) {
-    return {
-      ok: false,
-      noop: true,
-      error: "HUB_UNAVAILABLE",
-      command: String(command || "")
-        .trim()
-        .toLowerCase(),
-    };
-  }
-
-  return await publishLeadControl({
-    hubUrl: resolveHeadlessHubUrl(),
-    fromAgent: "lead",
-    toAgent: sessionAgentId,
-    command,
-    payload: {
-      session_name: String(sessionName || "").trim(),
-      target_worker: String(targetWorker || "*").trim() || "*",
-      issued_by: "lead",
-      issued_at: Date.now(),
-    },
-  });
-}