@triflux/remote 10.1.0 → 10.25.1

package/hub/team/recovery-store.mjs

@@ -0,0 +1,149 @@
+// hub/team/recovery-store.mjs — Best-effort preservation of worker changes
+// before a dirty worktree is removed. Uses file-based `.patch` + JSON manifest
+// instead of git stash (git-preflight flags stash-pop/worktree-remove as risky).
+
+import { execFile } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const DEFAULT_RECOVERY_DIR = ".codex-swarm/recovery";
+
+function git(args, cwd) {
+  return new Promise((res) => {
+    execFile(
+      "git",
+      args,
+      { cwd, windowsHide: true, timeout: 30_000, maxBuffer: 64 * 1024 * 1024 },
+      (err, stdout, stderr) => {
+        if (err) {
+          res({ ok: false, stderr: stderr?.toString() || err.message });
+        } else {
+          res({ ok: true, stdout });
+        }
+      },
+    );
+  });
+}
+
+function manifestPath(recoveryDir) {
+  return join(recoveryDir, "manifest.json");
+}
+
+function readManifestFile(recoveryDir) {
+  const path = manifestPath(recoveryDir);
+  if (!existsSync(path)) return { entries: [] };
+  try {
+    const raw = readFileSync(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && Array.isArray(parsed.entries)) return parsed;
+    return { entries: [] };
+  } catch {
+    return { entries: [] };
+  }
+}
+
+function writeManifestFile(recoveryDir, data) {
+  writeFileSync(manifestPath(recoveryDir), JSON.stringify(data, null, 2));
+}
+
+/**
+ * Preserve an uncommitted worker patch before the worktree is removed.
+ *
+ * Contract:
+ *  - Never throws.
+ *  - Dirty worktree  → write {recoveryDir}/{shardId}.patch, append manifest entry.
+ *  - Clean worktree  → return {ok: true, skipped: true}, no files written.
+ *  - Missing/invalid → return {ok: false, reason}, no throw.
+ *
+ * Patch captures `git diff HEAD` output (unified diff) — this covers both
+ * staged and unstaged changes relative to the shard's base commit.
+ *
+ * @param {object} opts
+ * @param {string} opts.worktreePath     — absolute path to the worker worktree
+ * @param {string} opts.shardId          — shard identifier (used for filename)
+ * @param {string} [opts.recoveryDir]    — default: `<worktreePath>/.codex-swarm/recovery`
+ *                                         when running inside worktree root;
+ *                                         callers typically pass repo-root relative path.
+ * @returns {Promise<
+ *   | { ok: true, patchPath: string, manifestPath: string }
+ *   | { ok: true, skipped: true }
+ *   | { ok: false, reason: string }
+ * >}
+ */
+export async function preserveWorktreePatch(opts = {}) {
+  const { worktreePath, shardId } = opts;
+
+  if (!worktreePath || typeof worktreePath !== "string") {
+    return { ok: false, reason: "missing_worktree_path" };
+  }
+  if (!shardId || typeof shardId !== "string") {
+    return { ok: false, reason: "missing_shard_id" };
+  }
+  if (!existsSync(worktreePath)) {
+    return { ok: false, reason: "worktree_path_not_found" };
+  }
+
+  const recoveryDir = opts.recoveryDir
+    ? resolve(opts.recoveryDir)
+    : resolve(worktreePath, DEFAULT_RECOVERY_DIR);
+
+  // Quickly classify dirty vs clean. `git status --porcelain` is safe and fast.
+  const status = await git(["status", "--porcelain"], worktreePath);
+  if (!status.ok) {
+    return { ok: false, reason: `git_status_failed: ${status.stderr}` };
+  }
+
+  if (status.stdout.trim().length === 0) {
+    return { ok: true, skipped: true };
+  }
+
+  // Dirty — capture diff.
+  const diff = await git(["diff", "HEAD"], worktreePath);
+  if (!diff.ok) {
+    return { ok: false, reason: `git_diff_failed: ${diff.stderr}` };
+  }
+
+  try {
+    mkdirSync(recoveryDir, { recursive: true });
+  } catch (err) {
+    return { ok: false, reason: `mkdir_failed: ${err.message}` };
+  }
+
+  const safeShardId = shardId.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const patchPath = join(recoveryDir, `${safeShardId}.patch`);
+  try {
+    writeFileSync(patchPath, diff.stdout);
+  } catch (err) {
+    return { ok: false, reason: `patch_write_failed: ${err.message}` };
+  }
+
+  const manifest = readManifestFile(recoveryDir);
+  manifest.entries.push({
+    shard: shardId,
+    patch: patchPath,
+    timestamp: new Date().toISOString(),
+  });
+  try {
+    writeManifestFile(recoveryDir, manifest);
+  } catch (err) {
+    return { ok: false, reason: `manifest_write_failed: ${err.message}` };
+  }
+
+  return { ok: true, patchPath, manifestPath: manifestPath(recoveryDir) };
+}
+
+/**
+ * Read the recovery manifest. Returns {entries: []} if missing or invalid.
+ * @param {string} recoveryDir
+ * @returns {{ entries: Array<{ shard: string, patch: string, timestamp: string }> }}
+ */
+export function readManifest(recoveryDir) {
+  if (!recoveryDir || typeof recoveryDir !== "string") {
+    return { entries: [] };
+  }
+  return readManifestFile(resolve(recoveryDir));
+}
+
+export const RECOVERY_DEFAULTS = Object.freeze({
+  dir: DEFAULT_RECOVERY_DIR,
+});

package/hub/team/remote-probe.mjs

@@ -7,8 +7,8 @@
 // L1.5: INPUT_WAIT 패턴 감지 (detectInputWait 재사용)
 // L3: 완료 토큰 감지 (__TRIFLUX_DONE__ 또는 프롬프트 idle)
 
-import { execFileSync } from 'node:child_process';
-import { detectInputWait, PROBE_DEFAULTS } from './health-probe.mjs';
+import { execFileSync } from "node:child_process";
+import { detectInputWait, PROBE_DEFAULTS } from "./health-probe.mjs";
 
 /** 완료 토큰 패턴 */
 const COMPLETION_TOKEN_RE = /__TRIFLUX_DONE__/;
@@ -27,19 +27,25 @@ const _PROMPT_IDLE_RE = /(\u276f|\u2795|>\s*$)/;
 export function sshCapturePane(host, paneTarget, lines = 20, deps = {}) {
   const execFn = deps.execFileSync || execFileSync;
   try {
-    const output = execFn('ssh', [
-      '-o', 'ConnectTimeout=5',
-      '-o', 'BatchMode=yes',
-      host,
-      `psmux capture-pane -t ${paneTarget} -p -S -`,
-    ], {
-      encoding: 'utf8',
-      timeout: 10_000,
-      windowsHide: true,
-      stdio: ['ignore', 'pipe', 'ignore'],
-    });
-    const nonEmpty = output.split('\n').filter((line) => line.trim() !== '');
-    return nonEmpty.slice(-lines).join('\n');
+    const output = execFn(
+      "ssh",
+      [
+        "-o",
+        "ConnectTimeout=5",
+        "-o",
+        "BatchMode=yes",
+        host,
+        `psmux capture-pane -t ${paneTarget} -p -S -`,
+      ],
+      {
+        encoding: "utf8",
+        timeout: 10_000,
+        windowsHide: true,
+        stdio: ["ignore", "pipe", "ignore"],
+      },
+    );
+    const nonEmpty = output.split("\n").filter((line) => line.trim() !== "");
+    return nonEmpty.slice(-lines).join("\n");
   } catch {
     return null;
   }
@@ -55,16 +61,22 @@ export function sshCapturePane(host, paneTarget, lines = 20, deps = {}) {
 export function sshSessionExists(host, sessionName, deps = {}) {
   const execFn = deps.execFileSync || execFileSync;
   try {
-    execFn('ssh', [
-      '-o', 'ConnectTimeout=5',
-      '-o', 'BatchMode=yes',
-      host,
-      `psmux has-session -t ${sessionName}`,
-    ], {
-      timeout: 10_000,
-      windowsHide: true,
-      stdio: ['ignore', 'ignore', 'ignore'],
-    });
+    execFn(
+      "ssh",
+      [
+        "-o",
+        "ConnectTimeout=5",
+        "-o",
+        "BatchMode=yes",
+        host,
+        `psmux has-session -t ${sessionName}`,
+      ],
+      {
+        timeout: 10_000,
+        windowsHide: true,
+        stdio: ["ignore", "ignore", "ignore"],
+      },
+    );
     return true;
   } catch {
     return false;
@@ -92,7 +104,7 @@ export function createRemoteProbe(session, opts = {}) {
   let started = false;
 
   // L1 tracking — 출력 변화 감지
-  let lastCaptureHash = '';
+  let lastCaptureHash = "";
   let lastOutputChangeAt = Date.now();
 
   // L3 tracking — 완료 토큰 / prompt idle
@@ -102,7 +114,7 @@ export function createRemoteProbe(session, opts = {}) {
   const status = {
     l0: null,
     l1: null,
-    l2: 'skip',  // 원격은 MCP L2 미지원
+    l2: "skip", // 원격은 MCP L2 미지원
     l3: null,
     lastProbeAt: null,
     inputWaitPattern: null,
@@ -113,7 +125,7 @@ export function createRemoteProbe(session, opts = {}) {
    */
   function probeL0() {
     const exists = sshSessionExists(session.host, session.sessionName, deps);
-    status.l0 = exists ? 'ok' : 'fail';
+    status.l0 = exists ? "ok" : "fail";
     return status.l0;
   }
 
@@ -135,9 +147,9 @@ export function createRemoteProbe(session, opts = {}) {
     if (hash !== lastCaptureHash) {
       lastCaptureHash = hash;
       lastOutputChangeAt = now;
-      status.l1 = 'ok';
+      status.l1 = "ok";
       status.inputWaitPattern = null;
-      return 'ok';
+      return "ok";
     }
 
     const silenceMs = now - lastOutputChangeAt;
@@ -147,18 +159,18 @@ export function createRemoteProbe(session, opts = {}) {
       const inputWait = detectInputWait(captured);
 
       if (inputWait.detected) {
-        status.l1 = 'input_wait';
+        status.l1 = "input_wait";
         status.inputWaitPattern = inputWait.pattern;
-        return 'input_wait';
+        return "input_wait";
       }
 
-      status.l1 = 'stall';
+      status.l1 = "stall";
       status.inputWaitPattern = null;
-      return 'stall';
+      return "stall";
     }
 
-    status.l1 = 'ok';
-    return 'ok';
+    status.l1 = "ok";
+    return "ok";
   }
 
   /**
@@ -167,28 +179,28 @@ export function createRemoteProbe(session, opts = {}) {
    */
   function probeL3(captured) {
     if (promptAcked) {
-      status.l3 = 'ok';
-      return 'ok';
+      status.l3 = "ok";
+      return "ok";
     }
 
     if (captured != null && captured.length > 0) {
       // 완료 토큰 감지 → 즉시 ok
       if (COMPLETION_TOKEN_RE.test(captured)) {
         promptAcked = true;
-        status.l3 = 'completed';
-        return 'completed';
+        status.l3 = "completed";
+        return "completed";
       }
 
       // 출력이 있으면 prompt acknowledged
       promptAcked = true;
-      status.l3 = 'ok';
-      return 'ok';
+      status.l3 = "ok";
+      return "ok";
     }
 
     const elapsed = Date.now() - spawnedAt;
     if (elapsed >= config.l3ThresholdMs) {
-      status.l3 = 'timeout';
-      return 'timeout';
+      status.l3 = "timeout";
+      return "timeout";
     }
 
     status.l3 = null;
@@ -204,7 +216,7 @@ export function createRemoteProbe(session, opts = {}) {
 
     // L0 실패 시 나머지 probe 스킵
     let captured = null;
-    if (l0 === 'ok') {
+    if (l0 === "ok") {
       captured = sshCapturePane(session.host, session.paneTarget, 20, deps);
     }
 
@@ -214,14 +226,14 @@ export function createRemoteProbe(session, opts = {}) {
     const result = {
       l0,
       l1,
-      l2: 'skip',
+      l2: "skip",
       l3,
       inputWaitPattern: status.inputWaitPattern,
       ts: Date.now(),
     };
     status.lastProbeAt = result.ts;
 
-    if (typeof config.onProbe === 'function') {
+    if (typeof config.onProbe === "function") {
       config.onProbe(result);
     }
 
@@ -233,10 +245,12 @@ export function createRemoteProbe(session, opts = {}) {
     started = true;
     spawnedAt = Date.now();
     lastOutputChangeAt = Date.now();
-    lastCaptureHash = '';
+    lastCaptureHash = "";
     promptAcked = false;
 
-    timer = setInterval(() => { void probe(); }, config.intervalMs);
+    timer = setInterval(() => {
+      void probe();
+    }, config.intervalMs);
     timer.unref?.();
 
     // 즉시 첫 probe 실행
@@ -254,13 +268,13 @@ export function createRemoteProbe(session, opts = {}) {
 
   /** tracking 리셋 (restart 후 호출) */
   function resetTracking() {
-    lastCaptureHash = '';
+    lastCaptureHash = "";
     lastOutputChangeAt = Date.now();
     promptAcked = false;
     spawnedAt = Date.now();
     status.l0 = null;
     status.l1 = null;
-    status.l2 = 'skip';
+    status.l2 = "skip";
     status.l3 = null;
     status.inputWaitPattern = null;
   }
@@ -271,6 +285,8 @@ export function createRemoteProbe(session, opts = {}) {
     probe,
     resetTracking,
     getStatus: () => ({ ...status }),
-    get started() { return started; },
+    get started() {
+      return started;
+    },
   });
 }