@triflux/remote 10.0.0 → 10.1.0

package/hub/team/tui.mjs

@@ -5,7 +5,6 @@
 import {
   RESET,
   FG,
-  BG,
   MOCHA,
   color,
   dim,
@@ -18,7 +17,6 @@ import {
   wcswidth,
   progressBar,
   statusBadge,
-  STATUS_ICON,
   altScreenOn,
   altScreenOff,
   clearScreen,
@@ -27,7 +25,6 @@ import {
   cursorShow,
   moveTo,
   clearLine,
-  clearToEnd,
 } from "./ansi.mjs";
 
 import { execFile as _execFile } from "node:child_process";
@@ -52,7 +49,7 @@ const SPINNER_FRAMES = [...SPINNER_FRAMES_RAW, ...[...SPINNER_FRAMES_RAW].revers
 const SPINNER_CYCLE_MS = 2000;
 const SPINNER_BASE_COLOR = { r: 203, g: 166, b: 247 }; // Catppuccin Mocha mauve
 const SPINNER_SHIMMER = { r: 171, g: 43, b: 63 };      // Claude shimmer #ab2b3f
-let spinnerStart = Date.now();
+const spinnerStart = Date.now();
 let spinnerTick = 0;
 
 function lerpRgb(a, b, t) {
@@ -119,7 +116,7 @@ function activityWave(tick, count = 4) {
 const GRID_GAP = 2;
 const DEFAULT_DETAIL_LINES = 10;
 // Tier1 상단 고정 행 수
-const TIER1_ROWS = 2;
+const _TIER1_ROWS = 2;
 
 const SUMMARY_KEYS = [
   "status", "lead_action", "verdict", "files_changed",
@@ -128,14 +125,14 @@ const SUMMARY_KEYS = [
 
 // ── 레이아웃 브레이크포인트 ──────────────────────────────────────────────
 // 80-119: 28col rail, 120-159: 36col rail, 160+: 균등
-function resolveRailWidth(totalCols, columnCount) {
+function _resolveRailWidth(totalCols, columnCount) {
   if (columnCount <= 1) return totalCols;
   if (totalCols >= 160) return Math.floor((totalCols - GRID_GAP * (columnCount - 1)) / columnCount);
   if (totalCols >= 120) return Math.min(36, Math.floor((totalCols - GRID_GAP * (columnCount - 1)) / columnCount));
   return Math.min(28, Math.floor((totalCols - GRID_GAP * (columnCount - 1)) / columnCount));
 }
 
-function autoColumnCount(totalCols, workerCount) {
+function _autoColumnCount(totalCols, workerCount) {
   if (workerCount <= 1) return 1;
   if (totalCols >= 160) return Math.min(workerCount, 3);
   if (totalCols >= 120) return Math.min(workerCount, 2);
@@ -154,7 +151,7 @@ function stripCodeBlocks(text) {
     .replace(/```[\s\S]*?(?:```|$)/g, "\n")
     .replace(/^\s*```.*$/gm, "")
     // indented code blocks (4+ spaces or tab at line start)
-    .replace(/^(?:    |\t).+$/gm, "")
+    .replace(/^(?: {4}|\t).+$/gm, "")
     // shell prompts: PS C:\...>, >, $
     .replace(/^(?:PS\s+\S[^\n]*?>|>\s+|\$\s+)[^\n]*/gm, "")
     .trim();
@@ -275,7 +272,7 @@ function gradientBorderFn(topRgb, bottomRgb) {
 }
 
 // Effect 3: Flash-fade border — 상태 변경 시 백색 플래시 → 페이드아웃
-function flashFadeBorderColor(currentStatus, prevStatus, changedAt) {
+function _flashFadeBorderColor(currentStatus, prevStatus, changedAt) {
   const elapsed = Date.now() - (changedAt || 0);
   if (elapsed >= FADE_DURATION_MS || !prevStatus) return null;
   const statusRgb = statusToRgb(currentStatus);
@@ -319,11 +316,11 @@ function dedupeRole(role, name, cli) {
   r = r.replace(new RegExp(esc(cli), "gi"), "").trim();
   r = r.replace(new RegExp(esc(name), "gi"), "").trim();
   // CLI indicator emojis 제거
-  r = r.replace(/[⚪⚫🔴🟠🟡🟢🔵🟣🟤⭕🔘]/g, "").trim();
+  r = r.replace(/[⚪⚫🔴🟠🟡🟢🔵🟣🟤⭕🔘]/gu, "").trim();
   // 빈 괄호 제거 + 중첩 괄호 정리
   r = r.replace(/\(\s*\)/g, "").trim();
   r = r.replace(/^\(([^()]+)\)$/, "$1").trim();
-  r = r.replace(/^\s*[•·\-]\s*/, "").trim();
+  r = r.replace(/^\s*[•·-]\s*/, "").trim();
   return r;
 }
 
@@ -350,7 +347,7 @@ function wrapLine(text, width) {
   return lines.length > 0 ? lines : [source.slice(0, limit)];
 }
 
-function wrapText(text, width, maxLines = DEFAULT_DETAIL_LINES, rawMode = false) {
+function _wrapText(text, width, maxLines = DEFAULT_DETAIL_LINES, rawMode = false) {
   if (maxLines <= 0) return [];
   const input = sanitizeTextBlock(text, rawMode);
   if (!input) return [];
@@ -465,7 +462,7 @@ function buildWorkerRail(name, st, opts = {}) {
     selected = false,
     focused = false,  // rail 포커스 여부
     previousSelected = false,
-    rawMode = false,
+    _rawMode = false,
     compact = false,
     time = Date.now(),
   } = opts;
@@ -713,7 +710,7 @@ function buildHelpOverlay(width, height) {
 }
 
 // ── joinColumns ───────────────────────────────────────────────────────────
-function joinColumns(blocks, gap = GRID_GAP) {
+function _joinColumns(blocks, gap = GRID_GAP) {
   const maxHeight = Math.max(...blocks.map((b) => b.length));
   return Array.from({ length: maxHeight }, (_, rowIdx) =>
     blocks
@@ -1418,7 +1415,7 @@ export function renderConductorTier(snapshot, cols = 100) {
   const dataLines = [];
   if (!snapshot || snapshot.length === 0) {
     const emptyMsg = color('(no sessions)', FG.muted);
-    const emptyPad = clip(stripAnsi(emptyMsg) === '(no sessions)' ? emptyMsg : emptyMsg, inner);
+    const _emptyPad = clip(stripAnsi(emptyMsg) === '(no sessions)' ? emptyMsg : emptyMsg, inner);
     dataLines.push(`${borderSeq}│${RESET} ${padRight(emptyMsg, inner - 2)} ${borderSeq}│${RESET}`);
   } else {
     for (const s of snapshot) {

package/hub/team/worktree-lifecycle.mjs

@@ -0,0 +1,229 @@
+// 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, validateHost } 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 */ }
+  }
+}
+
+/**
+ * Fetch a remote shard's branch to the local repo via SSH.
+ * Workaround for hosts that cannot push to GitHub (e.g. Ultra4).
+ *
+ * Flow: add temp remote → fetch branch → remove remote.
+ *
+ * @param {object} opts
+ * @param {string} opts.host — SSH host (e.g. "ultra4")
+ * @param {string} opts.sshUser — SSH user (e.g. "SSAFY")
+ * @param {string} opts.remoteRepoPath — absolute path on remote (e.g. "/c/Users/SSAFY/Desktop/Projects/cli/triflux")
+ * @param {string} opts.branchName — branch to fetch (e.g. "swarm/run123/auth")
+ * @param {string} [opts.rootDir=process.cwd()] — local repo root
+ * @returns {Promise<{ ok: boolean, localRef?: string, error?: string }>}
+ */
+export async function fetchRemoteShard({ host, sshUser, remoteRepoPath, branchName, rootDir = process.cwd() }) {
+  validateHost(host);
+
+  const remoteName = `_swarm-${host}-${Date.now()}`;
+  const sshUrl = `ssh://${sshUser}@${host}${remoteRepoPath}`;
+
+  try {
+    await git(['remote', 'add', remoteName, sshUrl], rootDir);
+
+    await git(['fetch', remoteName, branchName, '--no-tags'], rootDir);
+
+    const localRef = `${remoteName}/${branchName}`;
+    const headCommit = await git(['rev-parse', `FETCH_HEAD`], rootDir);
+
+    return { ok: true, localRef, headCommit };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  } finally {
+    try { await git(['remote', 'remove', remoteName], rootDir); } catch { /* cleanup */ }
+  }
+}