@triflux/remote 10.44.0 → 10.45.0

package/hub/team/session.mjs

@@ -475,6 +475,63 @@ export function attachSession(sessionName) {
   }
 }
 
+/**
+ * non-TTY 환경용 attach fallback: 요청 프로세스가 명시적으로 넘긴 lead pane을
+ * 분할해 그 pane 안에서 대상 세션에 attach한다.
+ *
+ * 호출 프로세스가 pipe(non-TTY)로 실행돼 attachSession()이 불가능해도,
+ * tmux 서버에 보내는 split-window는 호출자 TTY가 필요 없다. 새 pane에는
+ * tmux가 실제 pty를 붙여주므로 그 안의 attach는 정상 동작한다.
+ * env -u TMUX는 nested-attach 보호 해제용이다.
+ *
+ * @param {string} sessionName attach할 대상 세션
+ * @param {string} targetPane 요청 lead의 `$TMUX_PANE` (`%N`)
+ * @param {string} tmuxEnv 요청 lead의 `$TMUX` (`socket,pid,index`)
+ * @returns {boolean} 분할 attach 성공 여부 (false면 호출자가 기존 생략 경로 유지)
+ */
+export function buildSplitAttachArgs(sessionName, targetPane, tmuxEnv) {
+  const normalizedSessionName = String(sessionName || "");
+  if (!normalizedSessionName.trim()) {
+    throw new Error("session name is required");
+  }
+  if (!/^%\d+$/u.test(String(targetPane || ""))) {
+    throw new Error("requesting lead TMUX_PANE is required");
+  }
+  const socketPath = String(tmuxEnv || "").split(",", 1)[0];
+  if (!socketPath.trim()) {
+    throw new Error("requesting lead TMUX socket is required");
+  }
+  const quotedSocket = `'${socketPath.replace(/'/gu, "'\\''")}'`;
+  const quotedSessionName = `'${normalizedSessionName.replace(/'/gu, "'\\''")}'`;
+  return [
+    "split-window",
+    "-t",
+    targetPane,
+    "-v",
+    "-l",
+    "50%",
+    `env -u TMUX tmux -S ${quotedSocket} attach -t ${quotedSessionName}`,
+  ];
+}
+
+export function splitAttachToClient(sessionName, opts = {}) {
+  const deps = opts._deps || {};
+  const detectMux = deps.detectMultiplexer || detectMultiplexer;
+  if (detectMux() !== "tmux") return false;
+
+  let args;
+  try {
+    args = buildSplitAttachArgs(sessionName, opts.targetPane, opts.tmuxEnv);
+  } catch {
+    return false;
+  }
+
+  // 상하 분할: 좌우 분할은 절반 폭이 워커 pane 가독 하한(100cols) 미만인 경우가 흔함
+  const spawn = deps.spawnSync || spawnSync;
+  const split = spawn("tmux", args);
+  return (split.status ?? 1) === 0;
+}
+
 /**
  * tmux 세션 존재 확인
  * @param {string} sessionName

package/hub/team/synapse-http.mjs

@@ -1,6 +1,9 @@
-import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { dirname, join } from "node:path";
+import { normalizeRoleKey } from "@triflux/core/hub/role-contract.mjs";
 
 const HUB_DEFAULT_PORT = 27888;
 // Same token file as hub/bridge.mjs (HUB_TOKEN_FILE). Kept inline rather than
@@ -21,6 +24,144 @@ function normalizeToken(raw) {
   return token || null;
 }
 
+function opaqueId(prefix, value) {
+  return `${prefix}_${createHash("sha256")
+    .update(String(value || ""))
+    .digest("base64url")
+    .slice(0, 22)}`;
+}
+
+function normalizedProjectId(value) {
+  try {
+    return normalizeRoleKey({ project_id: value, role_kind: "cto" }).project_id;
+  } catch {
+    return "";
+  }
+}
+
+function resolveProjectId(cwd, meta, opts = {}) {
+  const explicit = meta?.project_id || process.env.TFX_PROJECT_ID;
+  if (explicit) return normalizedProjectId(explicit);
+  if (typeof opts.resolveProjectId === "function") {
+    return normalizedProjectId(opts.resolveProjectId(cwd));
+  }
+  let current = cwd;
+  while (current) {
+    const manifest = join(current, ".triflux", "project.json");
+    if (existsSync(manifest)) {
+      try {
+        const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+        if (parsed?.schema_version !== "tfx.project.v1") return "";
+        return normalizedProjectId(parsed.project_id);
+      } catch {
+        return "";
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return "";
+}
+
+function inferSessionCli(meta, opts = {}) {
+  const explicit = String(meta?.cli || meta?.actor_cli || "")
+    .trim()
+    .toLowerCase();
+  if (explicit === "codex" || explicit === "claude") return explicit;
+  const entrypoint = String(opts.entrypoint ?? process.argv[1] ?? "");
+  if (entrypoint.includes("codex-session-hook")) return "codex";
+  if (entrypoint.includes("agy-session-hook")) return "other";
+  return "claude";
+}
+
+function resolveTmuxSession(meta, opts = {}) {
+  const explicit =
+    meta?.tmux_session || meta?.session_name || process.env.TFX_TMUX_SESSION;
+  if (explicit) return String(explicit).trim();
+  if (!process.env.TMUX) return "";
+  try {
+    const run =
+      opts.tmuxSessionName ||
+      (() =>
+        execFileSync("tmux", ["display-message", "-p", "#{session_name}"], {
+          encoding: "utf8",
+          timeout: 200,
+          windowsHide: true,
+        }));
+    return String(run() || "").trim();
+  } catch {
+    return "";
+  }
+}
+
+export function buildSynapseRegistrationMeta(meta, opts = {}) {
+  if (!meta || meta.sessionKind !== "interactive") return meta;
+  const sessionId = String(meta.sessionId || "").trim();
+  if (!sessionId) return meta;
+  const cwd = typeof meta.cwd === "string" ? meta.cwd : process.cwd();
+  const cli = inferSessionCli(meta, opts);
+  const hostId = String(
+    meta.host_id ||
+      process.env.TFX_HOST_ID ||
+      opaqueId("hst", opts.hostname?.() || hostname()),
+  ).trim();
+  const expiresAtMs = Number(opts.nowMs?.() ?? Date.now()) + 299000;
+  const transportLocators = [];
+  if (cli === "claude") {
+    transportLocators.push({
+      schema_version: "tfx.transport-locator.v1",
+      transport_id: opaqueId("trn", `claude-uds:${hostId}:${sessionId}`),
+      kind: "claude-uds",
+      host_id: hostId,
+      capabilities: ["probe", "wake", "activate", "interrupt"],
+      priority: 100,
+      expires_at_ms: expiresAtMs,
+      locator: {
+        session_id: sessionId,
+        bridge_id: String(
+          meta.bridge_id || process.env.TFX_BRIDGE_ID || "local-hub",
+        ),
+      },
+    });
+  }
+  const tmuxSession = resolveTmuxSession(meta, opts);
+  if (tmuxSession) {
+    const muxServerSource =
+      meta.mux_server_id ||
+      process.env.TFX_MUX_SERVER_ID ||
+      String(process.env.TMUX || "default").split(",", 1)[0];
+    transportLocators.push({
+      schema_version: "tfx.transport-locator.v1",
+      transport_id: opaqueId("trn", `tmux:${hostId}:${tmuxSession}`),
+      kind: "tmux",
+      host_id: hostId,
+      capabilities: ["probe", "wake", "activate", "interrupt"],
+      priority: cli === "codex" ? 100 : 50,
+      expires_at_ms: expiresAtMs,
+      locator: {
+        session_name: tmuxSession,
+        mux_server_id: opaqueId("mux", muxServerSource),
+      },
+    });
+  }
+  const directAgentId = `session:${sessionId}`;
+  return {
+    ...meta,
+    agent_id:
+      meta.agent_id ||
+      (directAgentId.length <= 64 && /^[a-zA-Z0-9._:-]+$/u.test(directAgentId)
+        ? directAgentId
+        : opaqueId("session", sessionId)),
+    cli,
+    project_id: resolveProjectId(cwd, meta, opts) || undefined,
+    session_id: meta.session_id || sessionId,
+    host_id: hostId,
+    transport_locators_json:
+      meta.transport_locators_json ?? JSON.stringify(transportLocators),
+  };
+}
+
 // Mirrors hub/bridge.mjs:readHubToken — env override first, then the token file.
 // Missing token → null (backward-compatible with token-less hubs).
 function readHubToken() {
@@ -139,7 +280,11 @@ export function drainPendingSynapse(timeoutMs = 1000) {
 }
 
 export function registerSynapseSession(meta, opts = {}) {
-  return fireAndForgetSynapse("/synapse/register", meta, opts);
+  return fireAndForgetSynapse(
+    "/synapse/register",
+    buildSynapseRegistrationMeta(meta, opts),
+    opts,
+  );
 }
 
 export function heartbeatSynapseSession(

package/hub/team/terminal-opener.mjs

@@ -111,6 +111,35 @@ function wtResultSucceeded(result) {
   return result?.success !== false;
 }
 
+function resolveLeadPane(value) {
+  const pane = String(value || "");
+  return /^%\d+$/u.test(pane) ? pane : null;
+}
+
+function resolveLeadWindow(tmuxExec, targetPane) {
+  try {
+    const targetWindow = String(
+      tmuxExec(
+        `display-message -p -t ${targetPane} '#{session_name}:#{window_index}'`,
+      ) ?? "",
+    ).trim();
+    return targetWindow || null;
+  } catch {
+    return null;
+  }
+}
+
+function resolveLeadSocket(tmuxExec, targetPane) {
+  try {
+    const socketPath = String(
+      tmuxExec(`display-message -p -t ${targetPane} '#{socket_path}'`) ?? "",
+    ).trim();
+    return socketPath || null;
+  } catch {
+    return null;
+  }
+}
+
 export function createTerminalOpener(deps = {}) {
   const platform = resolvePlatform(deps);
   const tmuxExec = deps.tmuxExec || defaultTmuxExec;
@@ -134,12 +163,22 @@ export function createTerminalOpener(deps = {}) {
 
     const mux = resolveMux(deps);
     if (isTmuxLikeMux(mux, platform)) {
-      tmuxExec(
-        `new-window -n ${shellQuote(title)} ${shellQuote(
-          buildCommandString(spec),
-        )}`,
-      );
-      return true;
+      const targetPane = resolveLeadPane(spec.targetPane);
+      if (!targetPane) return false;
+      const targetWindow = resolveLeadWindow(tmuxExec, targetPane);
+      if (!targetWindow) return false;
+      try {
+        // tmux new-window는 pane target(%N)을 거부하므로, 요청 pane에서 해석한
+        // 정확한 session:window 뒤에 새 window를 삽입한다.
+        tmuxExec(
+          `new-window -a -t ${shellQuote(targetWindow)} -n ${shellQuote(
+            title,
+          )} ${shellQuote(buildCommandString(spec))}`,
+        );
+        return true;
+      } catch {
+        return false;
+      }
     }
 
     if (platform === "darwin") {
@@ -174,14 +213,30 @@ export function createTerminalOpener(deps = {}) {
 
     const mux = resolveMux(deps);
     if (isTmuxLikeMux(mux, platform)) {
-      const attachCommand = buildAttachCommand(mux, sessionName, deps);
+      const targetPane = resolveLeadPane(opts.targetPane);
+      if (!targetPane) return false;
+      const socketPath =
+        mux === "psmux" ? null : resolveLeadSocket(tmuxExec, targetPane);
+      if (mux !== "psmux" && !socketPath) return false;
+      const attachCommand =
+        mux === "psmux"
+          ? buildAttachCommand(mux, sessionName, deps)
+          : `env -u TMUX tmux -S ${shellQuote(
+              socketPath,
+            )} attach-session -t ${shellQuote(sessionName)}`;
       if (!attachCommand) return false;
-      tmuxExec(
-        `new-window -n ${shellQuote(opts.title ?? sessionName)} ${shellQuote(
-          attachCommand,
-        )}`,
-      );
-      return true;
+      const targetWindow = resolveLeadWindow(tmuxExec, targetPane);
+      if (!targetWindow) return false;
+      try {
+        tmuxExec(
+          `new-window -a -t ${shellQuote(targetWindow)} -n ${shellQuote(
+            opts.title ?? sessionName,
+          )} ${shellQuote(attachCommand)}`,
+        );
+        return true;
+      } catch {
+        return false;
+      }
     }
 
     return false;

package/hub/team/tui-viewer.mjs

@@ -11,6 +11,7 @@ import { join } from "node:path";
 import { formatPsmuxInstallGuidance } from "../../scripts/lib/psmux-info.mjs";
 import { openHeadlessDashboardTarget } from "./dashboard-open.mjs";
 import { processHandoff } from "./handoff.mjs";
+import { getMultiplexerType } from "./psmux.mjs";
 import { createLogDashboard } from "./tui.mjs";
 import { createLiteDashboard } from "./tui-lite.mjs";
 
@@ -24,23 +25,36 @@ function argVal(flag) {
 const SESSION = argVal("--session");
 const RESULT_DIR = argVal("--result-dir") ?? join(tmpdir(), "tfx-headless");
 const LAYOUT = argVal("--layout") ?? "single";
-
-if (!SESSION) {
+const SOURCE = argVal("--source") === "files" ? "files" : "mux";
+const LEAD_PANE = argVal("--lead-pane");
+const parsedWorkerCount = Number.parseInt(argVal("--workers") || "0", 10);
+const WORKER_COUNT = Number.isFinite(parsedWorkerCount)
+  ? Math.min(64, Math.max(0, parsedWorkerCount))
+  : 0;
+const MUX_BIN = getMultiplexerType();
+
+if (!SESSION || !/^[a-zA-Z0-9_-]+$/u.test(SESSION)) {
   process.stderr.write(
     "Usage: node tui-viewer.mjs --session <name> [--result-dir <dir>] [--layout <name>]\n",
   );
   process.exit(1);
 }
-
-try {
-  execFileSync("psmux", ["--version"], { encoding: "utf8", timeout: 2000 });
-} catch {
-  process.stderr.write(
-    `ERROR: psmux 미설치. 설치 방법:\n${formatPsmuxInstallGuidance("  ")}\n`,
-  );
+if (SOURCE === "files" && WORKER_COUNT === 0) {
+  process.stderr.write("ERROR: --source files requires --workers <count>\n");
   process.exit(1);
 }
 
+if (SOURCE === "mux") {
+  try {
+    execFileSync(MUX_BIN, ["-V"], { encoding: "utf8", timeout: 2000 });
+  } catch {
+    process.stderr.write(
+      `ERROR: primary multiplexer 미설치. 설치 방법:\n${formatPsmuxInstallGuidance("  ")}\n`,
+    );
+    process.exit(1);
+  }
+}
+
 // ── 메모리 보호 상수 ──
 const MAX_BODY_BYTES = 10240;
 
@@ -59,11 +73,13 @@ const tui = tuiFactory({
       worker: workerName,
       openAll: false,
       cwd: process.cwd(),
+      targetPane: LEAD_PANE,
     }),
   onOpenAllWorkers: () =>
     openHeadlessDashboardTarget(SESSION, {
       openAll: true,
       cwd: process.cwd(),
+      targetPane: LEAD_PANE,
     }),
 });
 const startTime = Date.now();
@@ -166,9 +182,16 @@ function estimateProgress(lines, context = {}) {
 
 // ── psmux 래퍼 ──
 function listPanes() {
+  if (SOURCE === "files") {
+    return Array.from({ length: WORKER_COUNT }, (_, index) => ({
+      index: index + 1,
+      title: `worker-${index + 1} (daemon)`,
+      pid: "",
+    }));
+  }
   try {
     const out = execFileSync(
-      "psmux",
+      MUX_BIN,
       [
         "list-panes",
         "-t",
@@ -192,9 +215,35 @@ function listPanes() {
 }
 
 function capturePane(paneIdx, lines = 20) {
+  if (SOURCE === "files") {
+    const base = join(RESULT_DIR, `${SESSION}-worker-${paneIdx}.txt`);
+    const artifacts = [
+      { path: base, label: "output" },
+      { path: `${base}.partial`, label: "daemon" },
+      { path: `${base}.err`, label: "stderr" },
+    ];
+    const snapshots = [];
+    for (const artifact of artifacts) {
+      try {
+        const content = readFileSync(artifact.path, "utf8").trim();
+        if (!content) continue;
+        snapshots.push(
+          `[${artifact.label}]\n${content.split("\n").slice(-lines).join("\n")}`,
+        );
+      } catch {
+        /* artifact is optional while the daemon job is starting */
+      }
+    }
+    return (
+      snapshots.join("\n") ||
+      `worker-${paneIdx} daemon active · waiting for output · ${Math.round(
+        (Date.now() - startTime) / 1000,
+      )}s`
+    );
+  }
   try {
     return execFileSync(
-      "psmux",
+      MUX_BIN,
       ["capture-pane", "-t", `${SESSION}:0.${paneIdx}`, "-p"],
       { encoding: "utf8", timeout: 2000 },
     )
@@ -368,7 +417,7 @@ function ingest() {
     const tokens = extractTokenLabel(snapshot);
     const elapsed = Math.round((Date.now() - startTime) / 1000);
 
-    if (resultSize > 10 || shellReturned) {
+    if (SOURCE !== "files" && (resultSize > 10 || shellReturned)) {
       const resultContent = existsSync(resultFile)
         ? readFileSync(resultFile, "utf8")
         : snapshot;
@@ -410,8 +459,10 @@ function ingest() {
     // 진행 중
     const progress = estimateProgress(lines, {
       tokens,
-      resultSize,
-      shellReturned,
+      // daemon output files grow while the job is still running; file size is
+      // activity evidence, not a completion signal in read-only file mode.
+      resultSize: SOURCE === "files" ? 0 : resultSize,
+      shellReturned: SOURCE === "files" ? false : shellReturned,
       done: false,
     });
     const verdict = lastLine;

package/hub/tools.mjs

@@ -159,8 +159,13 @@ export function createTools(store, router, hitl, pipe = null) {
           transport_locators_json: {
             description:
               "tfx.transport-locator.v1 객체 배열 또는 그 JSON 문자열",
-            oneOf: [{ type: "array", items: { type: "object" } }, { type: "string" }],
+            oneOf: [
+              { type: "array", items: { type: "object" } },
+              { type: "string" },
+            ],
           },
+          hub_instance_id: { type: "string" },
+          store_fingerprint: { type: "string" },
           heartbeat_ttl_ms: {
             type: "integer",
             minimum: 10000,
@@ -186,6 +191,8 @@ export function createTools(store, router, hitl, pipe = null) {
           agent_id: { type: "string" },
           trace_id: { type: "string" },
           include_metrics: { type: "boolean", default: true },
+          hub_instance_id: { type: "string" },
+          store_fingerprint: { type: "string" },
         },
       },
       handler: wrap("STATUS_FAILED", (args) => {
@@ -206,6 +213,8 @@ export function createTools(store, router, hitl, pipe = null) {
           agent_id: { type: "string", pattern: "^[a-zA-Z0-9._:-]{3,64}$" },
           reason: { type: "string" },
           requested_by: { type: "string" },
+          hub_instance_id: { type: "string" },
+          store_fingerprint: { type: "string" },
         },
       },
       handler: wrap("TAKEOVER_ROLE_FAILED", (args) => {

package/hub/workers/codex-mcp.mjs

@@ -8,6 +8,7 @@ import { fileURLToPath } from "node:url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 
+import { normalizeCodexProfileName } from "../../scripts/lib/codex-profile-config.mjs";
 import {
   CODEX_MCP_EXECUTION_EXIT_CODE,
   CODEX_MCP_TRANSPORT_EXIT_CODE,
@@ -134,11 +135,13 @@ function readTomlScalar(raw, key) {
 export function resolveCodexProfileConfig(profileName) {
   const result = { model: null, reasoningEffort: null };
   if (typeof profileName !== "string" || !profileName) return result;
+  const normalizedProfileName = normalizeCodexProfileName(profileName);
+  if (!normalizedProfileName) return result;
 
   const codexHome = process.env.CODEX_HOME || join(homedir(), ".codex");
   try {
     const raw = readFileSync(
-      join(codexHome, `${profileName}.config.toml`),
+      join(codexHome, `${normalizedProfileName}.config.toml`),
       "utf8",
     );
     result.model = readTomlScalar(raw, "model");
@@ -146,7 +149,9 @@ export function resolveCodexProfileConfig(profileName) {
   } catch {
     // Profile file absent (non-file alias). Derive effort from the naming
     // convention; leave model unset so codex uses its config.toml default.
-    const suffix = /_(ultra|max|xhigh|high|med|medium|low)$/.exec(profileName);
+    const suffix = /_(ultra|max|xhigh|high|med|medium|low)$/.exec(
+      normalizedProfileName,
+    );
     if (suffix) {
       const map = {
         ultra: "ultra",
@@ -198,7 +203,7 @@ export function buildCodexArguments(prompt, opts = {}) {
     const profileDerivedUltra =
       resolved.reasoningEffort?.toLowerCase() === "ultra";
     if (typeof args.model !== "string") {
-      if (profileDerivedUltra) args.model = "gpt-5.6-sol";
+      if (profileDerivedUltra) args.model = "gpt-6-astra";
       else if (resolved.model) args.model = resolved.model;
     }
     if (resolved.reasoningEffort) {

package/hub/workers/delegator-mcp.mjs

@@ -11,7 +11,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import * as z from "zod";
-import { resolveCodexAgentPolicy } from "@triflux/core/scripts/lib/agent-route-policy.mjs";
+import { resolveCodexAgentPolicy } from "../../scripts/lib/agent-route-policy.mjs";
 import { resolveBashExecutable } from "@triflux/core/hub/lib/bash-path.mjs";
 import { runHeadlessWithCleanup } from "../team/headless.mjs";
 import { buildWorkerSandboxEnv } from "../team/worker-sandbox.mjs";

package/package.json

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