@triflux/remote 10.25.1 → 10.27.0

package/hub/team/claude-native-bridge.mjs

@@ -7,6 +7,7 @@ import path from "node:path";
 import {
   buildDaemonExecDispatchPayload,
   killDaemonJob,
+  resolveDaemonBridgeSessionId,
   sendClaudeControlRequest,
   waitForDaemonJobPid,
 } from "./claude-daemon-control.mjs";
@@ -15,6 +16,7 @@ import {
   removeClaudeSessionProjection,
   writeClaudeSessionProjection,
 } from "./claude-session-projection.mjs";
+import { createInteractiveTuiTransport } from "./interactive-tui-transport.mjs";
 
 const DEFAULT_ROWS = 40;
 const DEFAULT_COLS = 120;
@@ -230,6 +232,30 @@ function buildSwarmShardBridgeCommand({ displayName, sessionId }) {
   return `printf '%s\\n' ${shellSingleQuote(banner)}; while true; do sleep 3600; done`;
 }
 
+function normalizeWorkerType(value) {
+  return value === "interactive" ? "interactive" : "headless";
+}
+
+function buildInteractiveTransportSessionName(...parts) {
+  const raw = parts.filter(Boolean).join("-");
+  return raw
+    .replace(/[^A-Za-z0-9_.-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 80);
+}
+
+function createStopOnce(transport) {
+  let stopPromise = null;
+  return () => {
+    if (!stopPromise) {
+      stopPromise = Promise.resolve()
+        .then(() => transport.stop())
+        .catch(() => {});
+    }
+    return stopPromise;
+  };
+}
+
 function compactDisplayPart(value, fallback = "") {
   const text = String(value ?? "")
     .replace(/[\u0000-\u001f\u007f]+/g, " ")
@@ -296,6 +322,10 @@ export async function registerSwarmShard({
   shardName,
   cwd = process.cwd(),
   host = "local",
+  interactive = false,
+  workerType,
+  launchCmd = "codex",
+  env = {},
   configDir = resolveClaudeConfigDir(),
   tmpRoot = "/tmp",
   _deps = {},
@@ -333,6 +363,8 @@ export async function registerSwarmShard({
   const sendControl =
     _deps.sendClaudeControlRequest || sendClaudeControlRequest;
   const waitForPid = _deps.waitForDaemonJobPid || waitForDaemonJobPid;
+  const resolveBridgeSessionId =
+    _deps.resolveDaemonBridgeSessionId || resolveDaemonBridgeSessionId;
   const readProcStart = _deps.getProcStart || getProcStart;
   const buildProjection =
     _deps.buildClaudeSessionProjection || buildClaudeSessionProjection;
@@ -340,6 +372,10 @@ export async function registerSwarmShard({
     _deps.writeClaudeSessionProjection || writeClaudeSessionProjection;
   const removeProjection =
     _deps.removeClaudeSessionProjection || removeClaudeSessionProjection;
+  const mergeRoster = _deps.mergeRosterWorkers || mergeRosterWorkers;
+  const removeRoster = _deps.removeRosterWorkers || removeRosterWorkers;
+  const createTransport =
+    _deps.createInteractiveTuiTransport || createInteractiveTuiTransport;
   const removeJobStateImpl = _deps.removeClaudeJobState || removeClaudeJobState;
   const killJob = _deps.killDaemonJob || killDaemonJob;
   const accessControlSock = _deps.accessControlSock || fs.access;
@@ -347,9 +383,103 @@ export async function registerSwarmShard({
   const paths = derivePaths({ configDir, tmpRoot });
   const sessionsDir =
     paths.sessionsDir || path.join(paths.configDir || configDir, "sessions");
-  const jobsDir = paths.jobsDir || path.join(paths.configDir || configDir, "jobs");
+  const jobsDir =
+    paths.jobsDir || path.join(paths.configDir || configDir, "jobs");
   const short = deriveSwarmShort({ sessionId, shardName, host });
   const command = buildSwarmShardBridgeCommand({ displayName, sessionId });
+  const resolvedWorkerType = interactive
+    ? "interactive"
+    : normalizeWorkerType(workerType);
+
+  if (resolvedWorkerType === "interactive") {
+    const rvSock = path.join(paths.rendezvousDir, `${short}.rv.sock`);
+    const ptySock = path.join(paths.ptyDir, `${short}.pty.sock`);
+    let facade = null;
+    let rosterWritten = false;
+    const transport = createTransport({
+      sessionName: buildInteractiveTransportSessionName(
+        "tfx",
+        "swarm",
+        sessionId,
+        shardName,
+        short,
+      ),
+      cwd,
+      launchCmd,
+      env,
+      onData(chunk) {
+        if (facade) facade.writeOutput(chunk);
+      },
+    });
+    const stopTransport = createStopOnce(transport);
+
+    try {
+      facade = await startNativeWorkerFacade({
+        short,
+        rvSock,
+        ptySock,
+        pid: process.pid,
+        initialDetail: `${cli}:${role}:interactive`,
+        workerType: "interactive",
+        onInput(payload) {
+          void Promise.resolve()
+            .then(() => transport.writeInput(payload))
+            .catch(() => {});
+        },
+        onResize(size) {
+          void Promise.resolve()
+            .then(() => transport.resize(size))
+            .catch(() => {});
+        },
+        onKill() {
+          void stopTransport();
+        },
+      });
+      await transport.start();
+      const rosterEntry = buildNativeWorkerRosterEntry({
+        short,
+        pid: process.pid,
+        procStart: readProcStart(process.pid),
+        sessionId,
+        cwd,
+        startedAt: Date.now(),
+        rendezvousSock: rvSock,
+        ptySock,
+        name: displayName,
+        prompt: displayName,
+      });
+      await mergeRoster(paths.rosterPath, { [short]: rosterEntry });
+      rosterWritten = true;
+    } catch (error) {
+      await stopTransport();
+      if (facade) await facade.close({ exitCode: 1 }).catch(() => {});
+      throw error;
+    }
+
+    let closed = false;
+    return {
+      ok: true,
+      skipped: false,
+      interactive: true,
+      host: "local",
+      sessionId,
+      swarmSessionId: sessionId,
+      shardName,
+      cli,
+      role,
+      short,
+      displayName,
+      rosterPath: paths.rosterPath,
+      async close() {
+        if (closed) return;
+        closed = true;
+        if (rosterWritten) await removeRoster(paths.rosterPath, [short]);
+        await stopTransport();
+        if (facade) await facade.close().catch(() => {});
+      },
+    };
+  }
+
   const payload = buildPayload({
     short,
     cwd,
@@ -376,6 +506,12 @@ export async function registerSwarmShard({
 
   const job = await waitForPid(paths.controlSock, short, { timeoutMs: 1000 });
   const pid = job.pid;
+  const bridgeSessionId = await resolveBridgeSessionId({
+    daemonPaths: paths,
+    short,
+    job,
+    timeoutMs: 1000,
+  });
   const projection = buildProjection({
     pid,
     procStart: readProcStart(pid),
@@ -386,6 +522,7 @@ export async function registerSwarmShard({
     agent: cli,
     startedAt: job.startedAt || Date.now(),
     updatedAt: Date.now(),
+    bridgeSessionId,
   });
   const sessionProjectionPath = await writeProjection(sessionsDir, projection);
   let closed = false;
@@ -469,6 +606,9 @@ export async function startNativeWorkerFacade({
   pid = process.pid,
   version = "triflux-native-bridge",
   initialDetail = "pending",
+  workerType = "headless",
+  onInput,
+  onResize,
   onKill,
 } = {}) {
   if (!short) throw new Error("short is required");
@@ -505,12 +645,19 @@ export async function startNativeWorkerFacade({
     transcript = trimTranscript(Buffer.concat([transcript, payload]));
     broadcastPty(buildPtyDataFrame(payload));
   };
+  const handlePtyInput =
+    workerType === "interactive" && typeof onInput === "function"
+      ? onInput
+      : appendOutput;
 
   const rvServer = net.createServer((socket) => {
     rvSockets.add(socket);
     events.push({ type: "rv-connect" });
     socket.setEncoding("utf8");
     socket.once("close", () => rvSockets.delete(socket));
+    socket.on("error", (error) => {
+      events.push({ type: "rv-socket-error", message: error.message });
+    });
     writeJsonLine(socket, { type: "heartbeat" });
     writeJsonLine(socket, { type: "state", patch: state });
     socket.on("data", (chunk) => {
@@ -546,6 +693,9 @@ export async function startNativeWorkerFacade({
     ptySockets.add(socket);
     events.push({ type: "pty-connect" });
     socket.once("close", () => ptySockets.delete(socket));
+    socket.on("error", (error) => {
+      events.push({ type: "pty-socket-error", message: error.message });
+    });
     socket.write(buildPtyControlFrame({ t: "hello", replPid: pid, version }));
     if (transcript.length > 0) socket.write(buildPtyDataFrame(transcript));
     socket.write(buildPtyControlFrame({ t: "live" }));
@@ -562,8 +712,25 @@ export async function startNativeWorkerFacade({
                 ? frame.ctrl
                 : { kind: 0, bytes: frame.payload.length },
           });
-          if (frame.kind === 0) appendOutput(frame.payload);
+          if (frame.kind === 0) handlePtyInput(frame.payload);
           else if (frame.ctrl.t === "resize") {
+            if (
+              workerType === "interactive" &&
+              typeof onResize === "function"
+            ) {
+              const cols = toPositiveInteger(frame.ctrl.cols);
+              const rows = toPositiveInteger(frame.ctrl.rows);
+              if (cols && rows) {
+                void Promise.resolve()
+                  .then(() => onResize({ cols, rows }))
+                  .catch((error) => {
+                    events.push({
+                      type: "pty-resize-error",
+                      message: error.message,
+                    });
+                  });
+              }
+            }
             socket.write(buildPtyControlFrame({ t: "live" }));
           } else if (frame.ctrl.t === "kill") {
             socket.write(
@@ -633,6 +800,10 @@ export async function startClaudeNativeBridge({
   procStart,
   tmpRoot = os.tmpdir(),
   onKill,
+  workerType = "headless",
+  launchCmd = "codex",
+  env = {},
+  createTransport = createInteractiveTuiTransport,
 } = {}) {
   if (!sessionName) throw new Error("sessionName is required");
   const paths = deriveClaudeDaemonPaths({ configDir, tmpRoot: "/tmp" });
@@ -647,6 +818,7 @@ export async function startClaudeNativeBridge({
   const startedAt = Date.now();
   const facades = [];
   const sentinels = [];
+  const transportStops = [];
   const rosterWorkers = {};
   const byPaneName = new Map();
 
@@ -675,15 +847,66 @@ export async function startClaudeNativeBridge({
       if (!workerPid) throw new Error("native bridge sentinel pid unavailable");
       const rvSock = path.join(socketRoot, `${short}.rv.sock`);
       const ptySock = path.join(socketRoot, `${short}.pty.sock`);
-      const facade = await startNativeWorkerFacade({
-        short,
-        rvSock,
-        ptySock,
-        pid: workerPid,
-        initialDetail: `${cli}:${role}:pending`,
-        onKill,
-      });
       const workerCwd = assignment.cwd || assignment.workdir || cwd;
+      const assignmentWorkerType = normalizeWorkerType(
+        assignment.workerType || workerType,
+      );
+      let facade = null;
+      if (assignmentWorkerType === "interactive") {
+        const transport = createTransport({
+          sessionName: buildInteractiveTransportSessionName(
+            sessionName,
+            paneName,
+            short,
+          ),
+          cwd: workerCwd,
+          launchCmd: assignment.launchCmd || launchCmd,
+          env: assignment.env || env,
+          onData(chunk) {
+            if (facade) facade.writeOutput(chunk);
+          },
+        });
+        const stopTransport = createStopOnce(transport);
+        transportStops.push(stopTransport);
+        facade = await startNativeWorkerFacade({
+          short,
+          rvSock,
+          ptySock,
+          pid: workerPid,
+          initialDetail: `${cli}:${role}:interactive`,
+          workerType: "interactive",
+          onInput(payload) {
+            void Promise.resolve()
+              .then(() => transport.writeInput(payload))
+              .catch(() => {});
+          },
+          onResize(size) {
+            void Promise.resolve()
+              .then(() => transport.resize(size))
+              .catch(() => {});
+          },
+          onKill(event) {
+            void stopTransport();
+            if (typeof onKill === "function") onKill(event);
+          },
+        });
+        try {
+          await transport.start();
+        } catch (error) {
+          await stopTransport();
+          await facade.close({ exitCode: 1 }).catch(() => {});
+          throw error;
+        }
+      } else {
+        facade = await startNativeWorkerFacade({
+          short,
+          rvSock,
+          ptySock,
+          pid: workerPid,
+          initialDetail: `${cli}:${role}:pending`,
+          onKill,
+        });
+      }
       rosterWorkers[short] = buildNativeWorkerRosterEntry({
         short,
         pid: workerPid,
@@ -696,11 +919,18 @@ export async function startClaudeNativeBridge({
         prompt: assignment.prompt || "",
       });
       facades.push(facade);
-      byPaneName.set(paneName, { facade, cli, role, short });
+      byPaneName.set(paneName, {
+        facade,
+        cli,
+        role,
+        short,
+        workerType: assignmentWorkerType,
+      });
     }
 
     await mergeRosterWorkers(paths.rosterPath, rosterWorkers);
   } catch (error) {
+    await Promise.all(transportStops.map((stop) => stop()));
     await Promise.all(facades.map((facade) => facade.close()));
     for (const sentinel of sentinels) {
       try {
@@ -720,6 +950,7 @@ export async function startClaudeNativeBridge({
     handleProgress(event) {
       const worker = byPaneName.get(event?.paneName);
       if (!worker) return;
+      if (worker.workerType === "interactive") return;
       if (event.type === "worker_added" || event.type === "dispatched") {
         worker.facade.update({
           state: "running",
@@ -753,6 +984,7 @@ export async function startClaudeNativeBridge({
     completeWorker(result) {
       const worker = byPaneName.get(result?.paneName);
       if (!worker) return;
+      if (worker.workerType === "interactive") return;
       worker.facade.writeOutput(
         `\r\n${String(result.output || "").slice(0, 4096)}\r\n`,
       );
@@ -766,6 +998,7 @@ export async function startClaudeNativeBridge({
       });
     },
     async close() {
+      await Promise.all(transportStops.map((stop) => stop()));
       await Promise.all(facades.map((facade) => facade.close()));
       await removeRosterWorkers(paths.rosterPath, Object.keys(rosterWorkers));
       for (const sentinel of sentinels) {

package/hub/team/claude-session-projection.mjs

@@ -1,6 +1,14 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 
+export function normalizeClaudeBridgeSessionId(bridgeSessionId, short) {
+  const value = String(bridgeSessionId || "").trim();
+  if (value.startsWith("session_")) return value;
+  if (value.startsWith("cse_")) return `session_${value.slice(4)}`;
+  if (value) return value;
+  return `session_${short}`;
+}
+
 export function buildClaudeSessionProjection({
   pid,
   procStart,
@@ -13,6 +21,7 @@ export function buildClaudeSessionProjection({
   updatedAt = Date.now(),
   status = "busy",
   version = "triflux-native-bridge",
+  bridgeSessionId,
 } = {}) {
   if (!Number.isInteger(pid) || pid <= 0) throw new Error("pid is required");
   if (!procStart) throw new Error("procStart is required");
@@ -36,7 +45,7 @@ export function buildClaudeSessionProjection({
     jobId: short,
     status,
     updatedAt,
-    bridgeSessionId: `session_${short}`,
+    bridgeSessionId: normalizeClaudeBridgeSessionId(bridgeSessionId, short),
   };
 }
 

package/hub/team/cli/commands/start/index.mjs

@@ -29,10 +29,10 @@ function printStartUsage() {
   console.log(`\n  ${AMBER}${BOLD}⬡ tfx multi${RESET}\n`);
   console.log(`  사용법: ${WHITE}tfx multi "작업 설명"${RESET}`);
   console.log(
-    `          ${WHITE}tfx multi --agents codex,gemini --lead claude "작업"${RESET}`,
+    `          ${WHITE}tfx multi --agents codex,antigravity --lead claude "작업"${RESET}`,
   );
   console.log(
-    `          ${WHITE}tfx multi --teammate-mode headless "작업"${RESET} ${DIM}(psmux 헤드리스, 기본)${RESET}`,
+    `          ${WHITE}tfx multi --teammate-mode headless "작업"${RESET} ${DIM}(headless workers)${RESET}`,
   );
   console.log(
     `          ${WHITE}tfx multi --dashboard-layout lite "작업"${RESET} ${DIM}(dashboard-lite 기본 뷰)${RESET}`,
@@ -66,10 +66,7 @@ function renderTmuxInstallHelp() {
   console.log(`\n  ${RED}${BOLD}tmux 미발견${RESET}\n`);
   console.log("  현재 선택한 모드는 tmux 기반 팀세션이 필요합니다.\n");
   console.log(
-    `  설치:\n    WSL2:   ${WHITE}wsl sudo apt install tmux${RESET}\n    macOS:  ${WHITE}brew install tmux${RESET}\n    Linux:  ${WHITE}apt install tmux${RESET}\n`,
-  );
-  console.log(
-    `  Windows에서는 WSL2를 권장합니다:\n    1. ${WHITE}wsl --install${RESET}\n    2. ${WHITE}wsl sudo apt install tmux${RESET}\n    3. ${WHITE}tfx multi "작업"${RESET}\n`,
+    `  설치:\n    Windows: ${WHITE}winget install psmux${RESET}\n    macOS:   ${WHITE}brew install tmux${RESET}\n    Linux:   ${WHITE}apt install tmux${RESET}\n`,
   );
 }
 

package/hub/team/cli/commands/start/parse-args.mjs

@@ -9,6 +9,8 @@ import {
 // --assign 파싱 시 마지막 콜론 뒤를 role로 인식할 알려진 역할/CLI 이름
 const KNOWN_ROLES = new Set([
   "codex",
+  "antigravity",
+  "agy",
   "gemini",
   "claude",
   "executor",
@@ -26,7 +28,12 @@ const KNOWN_ROLES = new Set([
   "scientist",
 ]);
 
-const NATIVE_BRIDGE_MODES = new Set(["roster", "agents", "claude-wrapper"]);
+const NATIVE_BRIDGE_MODES = new Set([
+  "roster",
+  "agents",
+  "interactive-attach",
+  "claude-wrapper",
+]);
 
 /**
  * --assign "cli:prompt:role" 형식을 콜론-안전하게 파싱한다.
@@ -59,7 +66,7 @@ function parseAssignValue(raw) {
 }
 
 export function parseTeamArgs(args = []) {
-  let agents = ["codex", "gemini"];
+  let agents = ["codex", "antigravity"];
   let lead = "claude";
   let layout = "2x2";
   let teammateMode = "auto";
@@ -153,7 +160,7 @@ export function parseTeamArgs(args = []) {
       const mode = args[++index];
       if (!NATIVE_BRIDGE_MODES.has(mode)) {
         throw new Error(
-          `unknown native bridge mode: ${mode || ""}; expected roster, agents, or claude-wrapper`,
+          `unknown native bridge mode: ${mode || ""}; expected roster, agents, interactive-attach, or claude-wrapper`,
         );
       }
       nativeBridge = true;

package/hub/team/cli/commands/start/start-headless.mjs

@@ -1,9 +1,50 @@
-import { resolveCliType, runHeadlessInteractive } from "../../../headless.mjs";
+import {
+  normalizeHeadlessRole,
+  resolveCliType,
+  resolveHeadlessDisplayName,
+  runHeadlessInteractive,
+} from "../../../headless.mjs";
 import { AMBER, DIM, GREEN, RESET } from "../../../shared.mjs";
 import { ok } from "../../render.mjs";
 import { clearTeamState } from "../../services/state-store.mjs";
 import { buildTasks } from "../../services/task-model.mjs";
 
+export function buildHeadlessAssignments({
+  agents = [],
+  subtasks = [],
+  assigns = [],
+  mcpProfile,
+  model,
+  cwd,
+} = {}) {
+  // --assign이 있으면 그것을 사용, 없으면 agents+subtasks 조합
+  return assigns && assigns.length > 0
+    ? assigns.map((a, i) => {
+        const paneName = `worker-${i + 1}`;
+        return {
+          cli: resolveCliType(a.cli),
+          prompt: a.prompt,
+          displayName: resolveHeadlessDisplayName(a, paneName),
+          role: normalizeHeadlessRole(a.role),
+          mcp: mcpProfile,
+          model,
+          cwd,
+        };
+      })
+    : subtasks.map((subtask, i) => {
+        const paneName = `worker-${i + 1}`;
+        return {
+          cli: resolveCliType(agents[i] || agents[0]),
+          prompt: subtask,
+          displayName: paneName,
+          role: "",
+          mcp: mcpProfile,
+          model,
+          cwd,
+        };
+      });
+}
+
 export async function startHeadlessTeam({
   sessionId,
   task,
@@ -26,25 +67,14 @@ export async function startHeadlessTeam({
   nativeBridge,
   nativeBridgeMode,
 }) {
-  // --assign이 있으면 그것을 사용, 없으면 agents+subtasks 조합
-  const assignments =
-    assigns && assigns.length > 0
-      ? assigns.map((a, i) => ({
-          cli: resolveCliType(a.cli),
-          prompt: a.prompt,
-          role: a.role || `worker-${i + 1}`,
-          mcp: mcpProfile,
-          model,
-          cwd,
-        }))
-      : subtasks.map((subtask, i) => ({
-          cli: resolveCliType(agents[i] || agents[0]),
-          prompt: subtask,
-          role: `worker-${i + 1}`,
-          mcp: mcpProfile,
-          model,
-          cwd,
-        }));
+  const assignments = buildHeadlessAssignments({
+    agents,
+    subtasks,
+    assigns,
+    mcpProfile,
+    model,
+    cwd,
+  });
 
   const _startedAt = Date.now();
   ok(`headless ${assignments.length}워커 시작`);

package/hub/team/cli/help.mjs

@@ -6,7 +6,7 @@ export function renderTeamHelp() {
 
   ${BOLD}시작${RESET}
     ${WHITE}tfx multi "작업 설명"${RESET}
-    ${WHITE}tfx multi --agents codex,gemini --lead claude "작업"${RESET}
+    ${WHITE}tfx multi --agents codex,antigravity --lead claude "작업"${RESET}
     ${WHITE}tfx multi --teammate-mode tmux "작업"${RESET}
     ${WHITE}tfx multi --teammate-mode wt "작업"${RESET}   ${DIM}(Windows Terminal split-pane)${RESET}
     ${WHITE}tfx multi --layout 1xN "작업"${RESET}               ${DIM}(세로 분할 컬럼)${RESET}

package/hub/team/cli/services/runtime-mode.mjs

@@ -9,12 +9,15 @@ export function normalizeTeammateMode(mode = "auto") {
   const raw = String(mode).toLowerCase();
   if (raw === "inline" || raw === "native") return "in-process";
   if (raw === "headless" || raw === "hl") return "headless";
-  if (raw === "psmux") return "headless";
-  if (raw === "in-process" || raw === "tmux" || raw === "wt") return raw;
+  if (raw === "in-process" || raw === "tmux" || raw === "psmux" || raw === "wt")
+    return raw;
   if (raw === "windows-terminal" || raw === "windows_terminal") return "wt";
   if (raw === "auto") {
     if (process.env.TMUX) return "tmux";
-    return detectMultiplexer() === "psmux" ? "headless" : "in-process";
+    const mux = detectMultiplexer();
+    if (mux === "psmux") return "psmux";
+    if (mux === "tmux") return "tmux";
+    return "in-process";
   }
   return "in-process";
 }