@triflux/remote 10.0.0-alpha.1

package/hub/team/cli/services/native-control.mjs

@@ -0,0 +1,117 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+
+import { buildLeadPrompt, buildPrompt } from "../../orchestrator.mjs";
+import { HUB_PID_DIR, PKG_ROOT } from "./state-store.mjs";
+
+import { buildExecArgs } from "../../../codex-adapter.mjs";
+
+export function buildNativeCliCommand(cli) {
+  switch (cli) {
+    case "codex":
+      return buildExecArgs({});
+    case "gemini":
+      return "gemini";
+    case "claude":
+      return "claude";
+    default:
+      return cli;
+  }
+}
+
+export async function startNativeSupervisor({ sessionId, task, lead, agents, subtasks, hubUrl }) {
+  const configPath = join(HUB_PID_DIR, `team-native-${sessionId}.config.json`);
+  const runtimePath = join(HUB_PID_DIR, `team-native-${sessionId}.runtime.json`);
+  const logsDir = join(HUB_PID_DIR, "team-logs", sessionId);
+  mkdirSync(logsDir, { recursive: true });
+
+  const leadMember = {
+    role: "lead",
+    name: "lead",
+    cli: lead,
+    agentId: `${lead}-lead`,
+    command: buildNativeCliCommand(lead),
+  };
+  const workers = agents.map((cli, index) => ({
+    role: "worker",
+    name: `${cli}-${index + 1}`,
+    cli,
+    agentId: `${cli}-w${index + 1}`,
+    command: buildNativeCliCommand(cli),
+    subtask: subtasks[index],
+  }));
+  const members = [
+    {
+      ...leadMember,
+      prompt: buildLeadPrompt(task, {
+        agentId: leadMember.agentId,
+        hubUrl,
+        teammateMode: "in-process",
+        workers: workers.map((worker) => ({
+          agentId: worker.agentId,
+          cli: worker.cli,
+          subtask: worker.subtask,
+        })),
+      }),
+    },
+    ...workers.map((worker) => ({
+      ...worker,
+      prompt: buildPrompt(worker.subtask, { cli: worker.cli, agentId: worker.agentId, hubUrl }),
+    })),
+  ];
+
+  writeFileSync(configPath, JSON.stringify({
+    sessionName: sessionId,
+    hubUrl,
+    startupDelayMs: 3000,
+    logsDir,
+    runtimeFile: runtimePath,
+    members,
+  }, null, 2) + "\n");
+
+  const child = spawn(process.execPath, [join(PKG_ROOT, "hub", "team", "native-supervisor.mjs"), "--config", configPath], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env },
+    windowsHide: true,
+  });
+  child.unref();
+
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (existsSync(runtimePath)) {
+      try {
+        const runtime = JSON.parse(readFileSync(runtimePath, "utf8"));
+        return { runtime, members };
+      } catch {}
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+
+  return { runtime: null, members };
+}
+
+export async function nativeRequest(state, path, body = {}) {
+  if (!state?.native?.controlUrl) return null;
+  try {
+    const res = await fetch(`${state.native.controlUrl}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+export async function nativeGetStatus(state) {
+  if (!state?.native?.controlUrl) return null;
+  try {
+    const res = await fetch(`${state.native.controlUrl}/status`);
+    return await res.json();
+  } catch {
+    return null;
+  }
+}

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

@@ -0,0 +1,62 @@
+import {
+  detectMultiplexer,
+  hasWindowsTerminal,
+  hasWindowsTerminalSession,
+  sessionExists,
+} from "../../session.mjs";
+
+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 === "windows-terminal" || raw === "windows_terminal") return "wt";
+  if (raw === "auto") {
+    if (process.env.TMUX) return "tmux";
+    return detectMultiplexer() === "psmux" ? "headless" : "in-process";
+  }
+  return "in-process";
+}
+
+export function normalizeLayout(layout = "2x2") {
+  const raw = String(layout).toLowerCase();
+  if (raw === "2x2" || raw === "grid") return "2x2";
+  if (raw === "1xn" || raw === "1x3" || raw === "vertical" || raw === "columns") return "1xN";
+  if (raw === "nx1" || raw === "horizontal" || raw === "rows") return "Nx1";
+  return "2x2";
+}
+
+export function isNativeMode(state) {
+  return state?.teammateMode === "in-process" && !!state?.native?.controlUrl;
+}
+
+export function isWtMode(state) {
+  return state?.teammateMode === "wt";
+}
+
+export function isTeamAlive(state) {
+  if (!state) return false;
+  if (isNativeMode(state)) {
+    try {
+      process.kill(state.native.supervisorPid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  if (isWtMode(state)) {
+    if (!hasWindowsTerminal()) return false;
+    if (hasWindowsTerminalSession()) return true;
+    return Array.isArray(state.members) && state.members.length > 0;
+  }
+  return sessionExists(state.sessionName);
+}
+
+export function ensureTmuxOrExit() {
+  const mux = detectMultiplexer();
+  if (mux) return mux;
+  const error = new Error("tmux 미발견");
+  error.code = "TMUX_REQUIRED";
+  throw error;
+}

package/hub/team/cli/services/state-store.mjs

@@ -0,0 +1,48 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+export const PKG_ROOT = fileURLToPath(new URL("../../../../", import.meta.url));
+export const HUB_PID_DIR = join(homedir(), ".claude", "cache", "tfx-hub");
+export const TEAM_PROFILE = (() => {
+  const raw = String(process.env.TFX_TEAM_PROFILE || "team").trim().toLowerCase();
+  return raw === "codex-team" ? "codex-team" : "team";
+})();
+
+export const SESSION_ID = process.env.CLAUDE_SESSION_ID || `s${Date.now()}`;
+
+function getStatePath(sessionId) {
+  if (sessionId) return join(HUB_PID_DIR, `team-state-${sessionId}.json`);
+  return join(HUB_PID_DIR, TEAM_PROFILE === "codex-team" ? "team-state-codex-team.json" : "team-state.json");
+}
+
+export function loadTeamState(sessionId) {
+  const resolvedId = sessionId || SESSION_ID;
+  const sessionPath = getStatePath(resolvedId);
+  try {
+    if (existsSync(sessionPath)) return JSON.parse(readFileSync(sessionPath, "utf8"));
+  } catch {
+    return null;
+  }
+  // 세션별 파일 없으면 기존 team-state.json fallback
+  const legacyPath = getStatePath(null);
+  try {
+    if (existsSync(legacyPath)) return JSON.parse(readFileSync(legacyPath, "utf8"));
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+export function saveTeamState(state, sessionId) {
+  const path = getStatePath(sessionId || state.sessionId || SESSION_ID);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify({ ...state, profile: TEAM_PROFILE }, null, 2) + "\n");
+}
+
+export function clearTeamState(sessionId) {
+  const path = getStatePath(sessionId || SESSION_ID);
+  if (existsSync(path)) unlinkSync(path);
+}

package/hub/team/cli/services/task-model.mjs

@@ -0,0 +1,30 @@
+export function buildTasks(subtasks, workers) {
+  return subtasks.map((subtask, index) => ({
+    id: `T${index + 1}`,
+    title: subtask,
+    owner: workers[index]?.name || null,
+    status: "pending",
+    depends_on: index === 0 ? [] : [`T${index}`],
+  }));
+}
+
+export function normalizeTaskStatus(action) {
+  const value = String(action || "").toLowerCase();
+  if (value === "done" || value === "complete" || value === "completed") return "completed";
+  if (value === "progress" || value === "in-progress" || value === "in_progress") return "in_progress";
+  if (value === "pending") return "pending";
+  return null;
+}
+
+export function updateTaskStatus(tasks = [], taskId, nextStatus) {
+  const normalizedId = String(taskId || "").toUpperCase();
+  const target = tasks.find((task) => String(task.id).toUpperCase() === normalizedId);
+  if (!target) return { tasks, target: null };
+
+  return {
+    target: { ...target, status: nextStatus },
+    tasks: tasks.map((task) => (
+      String(task.id).toUpperCase() === normalizedId ? { ...task, status: nextStatus } : task
+    )),
+  };
+}

package/hub/team/dashboard-anchor.mjs

@@ -0,0 +1,14 @@
+const DASHBOARD_ANCHORS = new Set([
+  "window",
+  "tab",
+]);
+
+export function normalizeDashboardAnchor(value) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) return "window";
+  return DASHBOARD_ANCHORS.has(normalized) ? normalized : "window";
+}
+
+export function parseDashboardAnchor(value) {
+  return normalizeDashboardAnchor(value);
+}

package/hub/team/dashboard-layout.mjs

@@ -0,0 +1,33 @@
+const USER_DASHBOARD_LAYOUTS = new Set([
+  "single",
+  "split-2col",
+  "split-3col",
+  "auto",
+  "lite",
+]);
+
+const DASHBOARD_LAYOUTS = new Set([
+  ...USER_DASHBOARD_LAYOUTS,
+  "summary+detail",
+]);
+
+export function normalizeDashboardLayout(value, { allowAuto = true } = {}) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) return "single";
+  if (normalized === "auto" && !allowAuto) return "single";
+  return DASHBOARD_LAYOUTS.has(normalized) ? normalized : "single";
+}
+
+export function parseDashboardLayout(value) {
+  return normalizeDashboardLayout(value, { allowAuto: true });
+}
+
+export function resolveDashboardLayout(value, workerCount = 0) {
+  const normalized = normalizeDashboardLayout(value, { allowAuto: true });
+  if (normalized === "lite") return "lite";
+  if (normalized !== "auto") return normalized;
+  if (workerCount >= 4) return "summary+detail";
+  if (workerCount === 3) return "split-3col";
+  if (workerCount === 2) return "split-2col";
+  return "single";
+}

package/hub/team/dashboard-open.mjs

@@ -0,0 +1,153 @@
+import { spawn } from "node:child_process";
+
+import { psmuxExec } from "./psmux.mjs";
+import {
+  detectMultiplexer,
+  focusWtPane,
+  hasWindowsTerminal,
+  resolveAttachCommand,
+  tmuxExec,
+} from "./session.mjs";
+
+function sanitizeWindowTitle(value, fallback = "triflux") {
+  const text = String(value || "").replace(/[\r\n]+/g, " ").trim();
+  return text || fallback;
+}
+
+function sanitizeSessionName(value) {
+  return String(value || "").replace(/[^a-zA-Z0-9_\-]/g, "") || "tfx-session";
+}
+
+function sanitizeWorkingDirectory(value) {
+  const text = String(value || "").replace(/[\r\n\x00-\x1f]/g, "").trim();
+  return text || process.cwd();
+}
+
+export function parseWorkerNumber(value) {
+  const text = String(value || "").trim();
+  const workerMatch = text.match(/^worker-(\d+)$/i);
+  if (workerMatch) return Number.parseInt(workerMatch[1], 10);
+  const paneMatch = text.match(/:(\d+)$/);
+  if (paneMatch) return Number.parseInt(paneMatch[1], 10);
+  return null;
+}
+
+export function decideDashboardOpenMode({ openAll = false, hasWtSession = !!process.env.WT_SESSION } = {}) {
+  if (openAll) return hasWtSession ? "tab" : "window";
+  return hasWtSession ? "split" : "window";
+}
+
+function spawnWindowsTerminal(spec, opts = {}) {
+  if (!hasWindowsTerminal()) return false;
+
+  const {
+    mode = "window",
+    title = "triflux",
+    cwd = process.cwd(),
+    split = { orientation: "H", size: 0.50 },
+  } = opts;
+
+  const safeTitle = sanitizeWindowTitle(title);
+  const safeCwd = sanitizeWorkingDirectory(cwd);
+  const orientation = split?.orientation === "V" ? "V" : "H";
+  const size = Number.isFinite(split?.size) ? Math.min(0.8, Math.max(0.2, split.size)) : 0.50;
+  const baseArgs = ["--profile", "triflux", "--title", safeTitle, "-d", safeCwd, "--", spec.command, ...spec.args];
+  const args = mode === "split"
+    ? ["-w", "0", "sp", `-${orientation}`, "-s", String(size), ...baseArgs]
+    : mode === "tab"
+      ? ["-w", "0", "nt", ...baseArgs]
+      : ["-w", "new", ...baseArgs];
+
+  const child = spawn("wt.exe", args, {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: false,
+  });
+  child.unref();
+  return true;
+}
+
+export function focusManagedPane(target, opts = {}) {
+  const { teammateMode = "", layout = "1xN" } = opts;
+  const paneRef = String(target || "");
+
+  if (teammateMode === "wt" || paneRef.startsWith("wt:")) {
+    const paneIndex = parseWorkerNumber(paneRef);
+    return paneIndex != null && focusWtPane(paneIndex, { layout });
+  }
+
+  if (!paneRef) return false;
+  try {
+    if (detectMultiplexer() === "psmux") psmuxExec(["select-pane", "-t", paneRef]);
+    else tmuxExec(`select-pane -t ${paneRef}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function openHeadlessDashboardTarget(sessionName, opts = {}) {
+  const {
+    worker = null,
+    openAll = false,
+    cwd = process.cwd(),
+    title,
+  } = opts;
+
+  const safeSession = sanitizeSessionName(sessionName);
+  const workerNumber = worker == null ? null : parseWorkerNumber(worker);
+
+  // 선택 워커 → pane focus만 (새 창 열지 않음)
+  if (!openAll && workerNumber != null) {
+    try {
+      psmuxExec(["select-pane", "-t", `${safeSession}:0.${workerNumber}`]);
+    } catch {}
+    return true;
+  }
+
+  // 전체 열기 (Shift+Enter) → 새 WT 창으로 세션 attach
+  return spawnWindowsTerminal(
+    { command: "psmux", args: ["attach-session", "-t", safeSession] },
+    {
+      mode: decideDashboardOpenMode({ openAll }),
+      title: title || `▲ ${safeSession}`,
+      cwd,
+    },
+  );
+}
+
+export function openDashboardRuntimeTarget(runtime, opts = {}) {
+  const {
+    teammateMode = "",
+    sessionName = "",
+    targetPane = "",
+    layout = "1xN",
+    openAll = false,
+    cwd = process.cwd(),
+    title = "",
+  } = { ...runtime, ...opts };
+
+  if (teammateMode === "headless") {
+    return openHeadlessDashboardTarget(sessionName, {
+      worker: openAll ? null : targetPane,
+      openAll,
+      cwd,
+      title,
+    });
+  }
+
+  if ((teammateMode === "wt" || String(targetPane).startsWith("wt:")) && !openAll) {
+    return focusManagedPane(targetPane, { teammateMode: "wt", layout });
+  }
+
+  try {
+    if (!openAll && targetPane) focusManagedPane(targetPane, { teammateMode, layout });
+    return spawnWindowsTerminal(resolveAttachCommand(sessionName), {
+      mode: decideDashboardOpenMode({ openAll }),
+      title: title || `▲ ${sanitizeSessionName(sessionName)}`,
+      cwd,
+    });
+  } catch {
+    return false;
+  }
+}