triflux 10.0.0 → 10.0.2

package/hub/team/worktree-lifecycle.mjs

@@ -0,0 +1,193 @@
+// hub/team/worktree-lifecycle.mjs — Git worktree lifecycle management
+// Replaces shell commands in tfx-codex-swarm Step 5 + merge-worktree Phase 6.
+// Convention: .codex-swarm/wt-{slug} paths, swarm/{runId}/{slug} branches.
+// Remote support: host option → SSH-based git operations via remote-session.mjs.
+
+import { execFile } from 'node:child_process';
+import { resolve, normalize } from 'node:path';
+import { mkdir, rm, access } from 'node:fs/promises';
+import { remoteGit } from './remote-session.mjs';
+
+const SWARM_ROOT = '.codex-swarm';
+const SLEEP_MS = 2000; // WT race-guard (MEMORY.md: wt-attach-spacing)
+
+function git(args, cwd) {
+  return new Promise((res, rej) => {
+    execFile('git', args, { cwd, windowsHide: true, timeout: 30_000 }, (err, stdout, stderr) => {
+      if (err) {
+        const msg = `git ${args[0]} failed: ${stderr?.trim() || err.message}`;
+        rej(new Error(msg));
+      } else {
+        res(stdout.trim());
+      }
+    });
+  });
+}
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+/** Normalize path for Windows compatibility. */
+function normPath(p) {
+  return normalize(p).replace(/\\/g, '/');
+}
+
+/**
+ * Create a worktree for a shard.
+ *
+ * @param {object} opts
+ * @param {string} opts.slug — shard identifier (e.g. "issue-42" or "auth-refactor")
+ * @param {string} opts.runId — swarm run ID
+ * @param {string} [opts.rootDir=process.cwd()] — repo root
+ * @param {string} [opts.baseBranch='main'] — base branch to branch from
+ * @param {string} [opts.host] — SSH host for remote worktree creation
+ * @param {object} [opts.remoteEnv] — remote environment from probeRemoteEnv()
+ * @returns {Promise<{ worktreePath: string, branchName: string, remote: boolean }>}
+ */
+export async function ensureWorktree({ slug, runId, rootDir = process.cwd(), baseBranch = 'main', host, remoteEnv }) {
+  const branchName = `swarm/${runId}/${slug}`;
+
+  // ── Remote path: SSH-based worktree creation ──
+  if (host && remoteEnv) {
+    const remoteRoot = rootDir.replace(/\\/g, '/');
+    const remoteWtDir = `${remoteRoot}/${SWARM_ROOT}/wt-${slug}`;
+
+    try { remoteGit(host, remoteEnv, ['worktree', 'prune'], remoteRoot); } catch { /* best-effort */ }
+
+    try {
+      remoteGit(host, remoteEnv, ['worktree', 'add', remoteWtDir, '-b', branchName, baseBranch], remoteRoot);
+    } catch {
+      try {
+        remoteGit(host, remoteEnv, ['worktree', 'add', remoteWtDir, branchName], remoteRoot);
+      } catch { /* already exists — acceptable */ }
+    }
+
+    return { worktreePath: remoteWtDir, branchName, remote: true };
+  }
+
+  // ── Local path (existing logic) ──
+  const wtDir = resolve(rootDir, SWARM_ROOT, `wt-${slug}`);
+
+  await mkdir(resolve(rootDir, SWARM_ROOT), { recursive: true });
+
+  // Check if worktree already exists
+  try {
+    await access(wtDir);
+    await git(['rev-parse', '--is-inside-work-tree'], wtDir);
+    return { worktreePath: normPath(wtDir), branchName, remote: false };
+  } catch {
+    // Doesn't exist or invalid — create fresh
+  }
+
+  try {
+    await git(['worktree', 'prune'], rootDir);
+  } catch { /* best-effort */ }
+
+  await sleep(SLEEP_MS);
+
+  try {
+    await git(['worktree', 'add', wtDir, '-b', branchName, baseBranch], rootDir);
+  } catch {
+    await git(['worktree', 'add', wtDir, branchName], rootDir);
+  }
+
+  return { worktreePath: normPath(wtDir), branchName, remote: false };
+}
+
+/**
+ * Create a temporary integration branch for merge operations.
+ *
+ * @param {object} opts
+ * @param {string} opts.runId
+ * @param {string} opts.baseBranch
+ * @param {string} [opts.rootDir=process.cwd()]
+ * @returns {Promise<{ integrationBranch: string, baseCommit: string }>}
+ */
+export async function prepareIntegrationBranch({ runId, baseBranch, rootDir = process.cwd() }) {
+  const integrationBranch = `swarm/${runId}/merge`;
+
+  // Record base commit for rollback
+  const baseCommit = await git(['rev-parse', baseBranch], rootDir);
+
+  // Create integration branch from base
+  try {
+    await git(['branch', integrationBranch, baseBranch], rootDir);
+  } catch {
+    // Branch may already exist — reset to base
+    await git(['branch', '-f', integrationBranch, baseBranch], rootDir);
+  }
+
+  return { integrationBranch, baseCommit };
+}
+
+/**
+ * Rebase a shard branch onto the integration branch.
+ * Uses rebase + fast-forward only (no merge commits).
+ *
+ * @param {object} opts
+ * @param {string} opts.shardBranch — the shard's branch name
+ * @param {string} opts.integrationBranch — target integration branch
+ * @param {string} [opts.rootDir=process.cwd()]
+ * @returns {Promise<{ ok: boolean, headCommit?: string, error?: string }>}
+ */
+export async function rebaseShardOntoIntegration({ shardBranch, integrationBranch, rootDir = process.cwd() }) {
+  // Backup integration HEAD for rollback
+  const backupCommit = await git(['rev-parse', integrationBranch], rootDir);
+
+  try {
+    // Rebase shard onto integration
+    await git(['rebase', integrationBranch, shardBranch], rootDir);
+
+    // Fast-forward integration to include shard changes
+    await git(['checkout', integrationBranch], rootDir);
+    await git(['merge', '--ff-only', shardBranch], rootDir);
+
+    const headCommit = await git(['rev-parse', 'HEAD'], rootDir);
+    return { ok: true, headCommit };
+  } catch (err) {
+    // Abort rebase and restore integration branch
+    try { await git(['rebase', '--abort'], rootDir); } catch { /* already clean */ }
+    try { await git(['checkout', integrationBranch], rootDir); } catch { /* best-effort */ }
+    try { await git(['reset', '--hard', backupCommit], rootDir); } catch { /* best-effort */ }
+
+    return { ok: false, error: err.message };
+  }
+}
+
+/**
+ * Remove a worktree and its branch.
+ * Follows WT race-guard: sleep between operations.
+ *
+ * @param {object} opts
+ * @param {string} opts.worktreePath
+ * @param {string} [opts.branchName] — optional branch to delete
+ * @param {string} [opts.rootDir=process.cwd()]
+ * @param {boolean} [opts.force=false]
+ */
+export async function pruneWorktree({ worktreePath, branchName, rootDir = process.cwd(), force = false }) {
+  const forceFlag = force ? '--force' : '';
+
+  // Remove worktree (with retry for Windows file handle issues — E5)
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      await git(['worktree', 'remove', worktreePath, ...(forceFlag ? [forceFlag] : [])], rootDir);
+      break;
+    } catch (err) {
+      if (attempt === 2) {
+        // Last resort: rm the directory and prune
+        try { await rm(worktreePath, { recursive: true, force: true }); } catch { /* ignore */ }
+      }
+      await sleep(SLEEP_MS);
+    }
+  }
+
+  // Prune stale worktree references
+  await sleep(SLEEP_MS);
+  try { await git(['worktree', 'prune'], rootDir); } catch { /* best-effort */ }
+
+  // Delete branch if specified
+  if (branchName) {
+    try { await git(['branch', '-D', branchName], rootDir); } catch { /* may not exist */ }
+  }
+}

package/hub/team/wt-manager.mjs

@@ -0,0 +1,407 @@
+import childProcess from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { platform as osPlatform, tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { sendKeysToPane } from "./psmux.mjs";
+
+const DEFAULT_WINDOW_NAME = "triflux";
+const DEFAULT_MAX_TABS = 8;
+const DEFAULT_TAB_CREATE_DELAY_MS = 500;
+const DEFAULT_WAIT_TIMEOUT_MS = 5_000;
+const DEFAULT_WAIT_POLL_MS = 300;
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}
+
+function resolvePositiveInteger(...values) {
+  for (const value of values) {
+    const parsed = Number.parseInt(String(value ?? ""), 10);
+    if (Number.isInteger(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return null;
+}
+
+function sanitizeTitleForPidFile(title) {
+  const sanitized = [...String(title).trim()]
+    .map((character) => {
+      const code = character.charCodeAt(0);
+      return code <= 31 || '<>:"/\\|?*'.includes(character) ? "_" : character;
+    })
+    .join("");
+
+  return (
+    sanitized
+      .replace(/\s+/gu, "-")
+      .replace(/_+/gu, "_")
+      .replace(/-+/gu, "-")
+      .replace(/^[-_]+|[-_]+$/gu, "") || "wt-tab"
+  );
+}
+
+function escapePowerShellSingleQuoted(value) {
+  return String(value).replace(/'/g, "''");
+}
+
+function buildPidFilePath(pidDir, title) {
+  return join(pidDir, `${sanitizeTitleForPidFile(title)}.pid`);
+}
+
+function buildWrappedCommand(pidFile, command) {
+  const escapedPidFile = escapePowerShellSingleQuoted(pidFile);
+  const pidWrite = `$PID | Set-Content '${escapedPidFile}'`;
+  return command ? `${pidWrite}; ${command}` : pidWrite;
+}
+
+/**
+ * PowerShell -EncodedCommand용 Base64 인코딩.
+ * CreateProcess 이중 쿼팅 문제를 완전히 회피한다.
+ */
+function encodeForPowerShell(script) {
+  const buf = Buffer.from(script, 'utf16le');
+  return buf.toString('base64');
+}
+
+function matchesTitlePattern(title, pattern) {
+  if (!pattern) return true;
+  if (pattern instanceof RegExp) return pattern.test(title);
+  return String(title).includes(String(pattern));
+}
+
+function defaultIsPidAlive(pid, execFileSyncFn = childProcess.execFileSync) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    // tasklist fallback — process.kill(..., 0)이 권한/플랫폼 차이로 실패할 수 있음.
+  }
+
+  try {
+    const output = execFileSyncFn(
+      "tasklist",
+      ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"],
+      {
+        encoding: "utf8",
+        timeout: 3_000,
+        stdio: ["ignore", "pipe", "ignore"],
+        windowsHide: true,
+      },
+    );
+    return (
+      !/No tasks are running/u.test(String(output)) &&
+      String(output).includes(`"${pid}"`)
+    );
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Windows Terminal 탭/세션 라이프사이클 관리자.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.windowName='triflux']
+ * @param {number} [opts.maxTabs=8]
+ * @param {string} [opts.pidDir=os.tmpdir()/wt-manager-pids]
+ * @param {number} [opts.tabCreateDelayMs=500]
+ * @param {object} [opts.deps] — 테스트용 의존성 주입
+ */
+export function createWtManager(opts = {}) {
+  const deps = opts.deps || {};
+  const platform = deps.platform || osPlatform;
+
+  if (platform() !== "win32") {
+    throw new Error("wt-manager.mjs is Windows-only");
+  }
+
+  const now = deps.now || Date.now;
+  const sleepFn = deps.sleep || sleep;
+  const spawnFn = deps.spawn || childProcess.spawn;
+  const execFileSyncFn = deps.execFileSync || childProcess.execFileSync;
+  const killFn = deps.kill || ((pid) => process.kill(pid));
+  const sendKeysFn = deps.sendKeysToPane || sendKeysToPane;
+  const isPidAlive =
+    deps.isPidAlive || ((pid) => defaultIsPidAlive(pid, execFileSyncFn));
+  const ensureDir =
+    deps.ensureDir || ((dir) => mkdirSync(dir, { recursive: true }));
+  const exists = deps.exists || existsSync;
+  const readText =
+    deps.readText || ((filePath) => readFileSync(filePath, "utf8"));
+  const removeFile =
+    deps.removeFile || ((filePath) => rmSync(filePath, { force: true }));
+
+  const windowName = String(opts.windowName || DEFAULT_WINDOW_NAME);
+  const maxTabs =
+    resolvePositiveInteger(
+      opts.maxTabs,
+      process.env.WTM_MAX_TABS,
+      DEFAULT_MAX_TABS,
+    ) || DEFAULT_MAX_TABS;
+  const pidDir = String(opts.pidDir || join(tmpdir(), "wt-manager-pids"));
+  const tabCreateDelayMs =
+    resolvePositiveInteger(
+      opts.tabCreateDelayMs,
+      DEFAULT_TAB_CREATE_DELAY_MS,
+    ) || DEFAULT_TAB_CREATE_DELAY_MS;
+
+  ensureDir(pidDir);
+
+  /** @type {Map<string, { pid: number, createdAt: number, pidFile: string }>} */
+  const tabs = new Map();
+  let lastTabCreateAt = null;
+
+  function forgetTab(title) {
+    const entry = tabs.get(title);
+    if (entry) {
+      tabs.delete(title);
+      try {
+        removeFile(entry.pidFile);
+      } catch {
+        /* ignore */
+      }
+    }
+  }
+
+  function pruneDeadTabs() {
+    for (const [title, entry] of tabs.entries()) {
+      if (!isPidAlive(entry.pid)) {
+        forgetTab(title);
+      }
+    }
+  }
+
+  async function throttleTabCreate() {
+    if (lastTabCreateAt == null) return;
+    const elapsed = now() - lastTabCreateAt;
+    if (elapsed < tabCreateDelayMs) {
+      await sleepFn(tabCreateDelayMs - elapsed);
+    }
+  }
+
+  async function waitTabReady(title, pidFile) {
+    const deadline = now() + DEFAULT_WAIT_TIMEOUT_MS;
+
+    while (now() <= deadline) {
+      if (exists(pidFile)) {
+        const pid = Number.parseInt(String(readText(pidFile)).trim(), 10);
+        if (Number.isInteger(pid) && pid > 0 && isPidAlive(pid)) {
+          return pid;
+        }
+      }
+
+      const remaining = deadline - now();
+      if (remaining <= 0) break;
+      await sleepFn(Math.min(DEFAULT_WAIT_POLL_MS, remaining));
+    }
+
+    throw new Error(`WT tab ready timeout: ${title}`);
+  }
+
+  async function createTab(tab = {}) {
+    const title = String(tab.title || "").trim();
+    if (!title) {
+      throw new Error("title is required");
+    }
+
+    pruneDeadTabs();
+
+    if (tabs.has(title)) {
+      throw new Error(`WT tab already exists: ${title}`);
+    }
+
+    if (tabs.size >= maxTabs) {
+      throw new Error(`WT max tabs exceeded (${maxTabs})`);
+    }
+
+    await throttleTabCreate();
+
+    const pidFile = buildPidFilePath(pidDir, title);
+    try {
+      removeFile(pidFile);
+    } catch {
+      /* ignore */
+    }
+
+    const args = ["-w", windowName, "nt", "--title", title];
+    if (tab.profile) {
+      args.push("--profile", String(tab.profile));
+    }
+    if (tab.cwd) {
+      args.push("-d", String(tab.cwd));
+    }
+    const script = buildWrappedCommand(pidFile, tab.command);
+    args.push(
+      "--",
+      "powershell.exe",
+      "-NoExit",
+      "-EncodedCommand",
+      encodeForPowerShell(script),
+    );
+
+    const child = spawnFn("wt.exe", args, {
+      detached: true,
+      stdio: "ignore",
+    });
+    child?.unref?.();
+
+    lastTabCreateAt = now();
+    const pid = await waitTabReady(title, pidFile);
+    const entry = Object.freeze({
+      pid,
+      createdAt: now(),
+      pidFile,
+    });
+    tabs.set(title, entry);
+  }
+
+  async function closeTab(title) {
+    const normalizedTitle = String(title || "").trim();
+    if (!normalizedTitle) return;
+
+    const entry = tabs.get(normalizedTitle);
+    if (!entry) return;
+
+    try {
+      killFn(entry.pid);
+    } catch {
+      // 이미 종료된 PID는 map 정리만 수행한다.
+    }
+
+    forgetTab(normalizedTitle);
+  }
+
+  function listTabs() {
+    pruneDeadTabs();
+    return [...tabs.entries()].map(([title, entry]) =>
+      Object.freeze({
+        title,
+        pid: entry.pid,
+        createdAt: entry.createdAt,
+      }),
+    );
+  }
+
+  async function closeStale(closeOpts = {}) {
+    pruneDeadTabs();
+
+    const olderThanMs = Number.isFinite(closeOpts.olderThanMs)
+      ? Math.max(0, Math.trunc(closeOpts.olderThanMs))
+      : 0;
+    const titlePattern = closeOpts.titlePattern;
+    const snapshot = [...tabs.entries()];
+    let closed = 0;
+
+    for (const [title, entry] of snapshot) {
+      const ageMs = now() - entry.createdAt;
+      if (ageMs < olderThanMs) continue;
+      if (!matchesTitlePattern(title, titlePattern)) continue;
+      await closeTab(title);
+      closed += 1;
+    }
+
+    return closed;
+  }
+
+  /**
+   * 현재 탭을 split-pane으로 분할.
+   * @param {object} opts
+   * @param {'H'|'V'} [opts.direction='V'] — H=좌우, V=상하
+   * @param {string} [opts.title]
+   * @param {string} [opts.profile]
+   * @param {string} [opts.cwd]
+   * @param {string} [opts.command] — pane에서 실행할 명령
+   * @param {number} [opts.size] — 퍼센트 (0-100)
+   */
+  async function splitPane(opts = {}) {
+    const direction = opts.direction === 'H' ? '-H' : '-V';
+    const args = ['-w', windowName, 'sp', direction];
+
+    if (opts.title) {
+      args.push('--title', String(opts.title));
+    }
+    if (opts.profile) {
+      args.push('--profile', String(opts.profile));
+    }
+    if (opts.size && Number.isFinite(opts.size)) {
+      args.push('-s', String(opts.size / 100));
+    }
+    if (opts.cwd) {
+      args.push('-d', String(opts.cwd));
+    }
+    if (opts.command) {
+      const script = opts.command;
+      args.push('--', 'powershell.exe', '-NoExit', '-EncodedCommand', encodeForPowerShell(script));
+    }
+
+    const child = spawnFn('wt.exe', args, {
+      detached: true,
+      stdio: 'ignore',
+    });
+    child?.unref?.();
+
+    // split-pane은 기존 탭 안에서 분할하므로 throttle 적용
+    await sleepFn(tabCreateDelayMs);
+  }
+
+  /**
+   * 여러 세션을 split-pane 레이아웃으로 한번에 배치.
+   * @param {Array<{title: string, command: string, direction?: 'H'|'V', size?: number}>} panes
+   */
+  async function applySplitLayout(panes) {
+    if (!panes || panes.length === 0) return;
+
+    // 첫 번째는 새 탭으로 생성
+    const first = panes[0];
+    await createTab({ title: first.title, command: first.command, profile: first.profile });
+
+    // 나머지는 split-pane으로 분할
+    for (let i = 1; i < panes.length; i++) {
+      await splitPane({
+        direction: panes[i].direction || 'V',
+        title: panes[i].title,
+        command: panes[i].command,
+        profile: panes[i].profile,
+        size: panes[i].size,
+      });
+    }
+  }
+
+  async function createSession(sessionOpts = {}) {
+    const tab =
+      typeof sessionOpts.tab === "string"
+        ? { title: sessionOpts.tab }
+        : sessionOpts.tab;
+
+    if (!tab || typeof tab !== "object") {
+      throw new Error("tab is required");
+    }
+    if (!sessionOpts.pane) {
+      throw new Error("pane is required");
+    }
+    if (!sessionOpts.command) {
+      throw new Error("command is required");
+    }
+
+    await createTab(tab);
+    sendKeysFn(String(sessionOpts.pane), String(sessionOpts.command), true);
+  }
+
+  function getTabCount() {
+    pruneDeadTabs();
+    return tabs.size;
+  }
+
+  return Object.freeze({
+    createTab,
+    closeTab,
+    listTabs,
+    closeStale,
+    createSession,
+    splitPane,
+    applySplitLayout,
+    getTabCount,
+  });
+}

package/hub/team/wt-templates.json

@@ -0,0 +1,43 @@
+{
+  "version": 1,
+  "templates": {
+    "swarm-3": {
+      "description": "Lead tab plus two worker tabs in the shared triflux window.",
+      "windowName": "triflux",
+      "tabs": [
+        {
+          "title": "swarm lead",
+          "profile": "triflux"
+        },
+        {
+          "title": "swarm worker-1",
+          "profile": "triflux"
+        },
+        {
+          "title": "swarm worker-2",
+          "profile": "triflux"
+        }
+      ]
+    },
+    "monitor": {
+      "description": "Single monitoring tab for dashboard, log tailing, or observer flows.",
+      "windowName": "triflux",
+      "tabs": [
+        {
+          "title": "swarm monitor",
+          "profile": "triflux"
+        }
+      ]
+    },
+    "single": {
+      "description": "One focused tab for direct operator work.",
+      "windowName": "triflux",
+      "tabs": [
+        {
+          "title": "single worker",
+          "profile": "triflux"
+        }
+      ]
+    }
+  }
+}

package/hub/team-bridge.mjs

@@ -0,0 +1,27 @@
+// @triflux/core — team-bridge 인터페이스
+// remote 패키지가 런타임에 구현을 주입한다.
+
+/**
+ * @typedef {object} TeamBridge
+ * @property {(args?: object) => Promise<object>} teamInfo
+ * @property {(args?: object) => Promise<object>} teamTaskList
+ * @property {(args?: object) => Promise<object>} teamTaskUpdate
+ * @property {(args?: object) => Promise<object>} teamSendMessage
+ */
+
+/** @type {TeamBridge | null} */
+let _bridge = null;
+
+/**
+ * @param {TeamBridge | null} impl
+ */
+export function registerTeamBridge(impl) {
+  _bridge = impl;
+}
+
+/**
+ * @returns {TeamBridge | null}
+ */
+export function getTeamBridge() {
+  return _bridge;
+}