@triflux/remote 10.1.0 → 10.26.0

package/hub/team/execution-mode.mjs

@@ -0,0 +1,256 @@
+// hub/team/execution-mode.mjs — headless vs interactive execution mode selection
+
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve as pathResolve } from "node:path";
+
+import { whichCommand } from "@triflux/core/hub/platform.mjs";
+
+const WIN32_EXT_PRECEDENCE = [".cmd", ".exe", ".bat", ".ps1"];
+
+// #128: parse npm-cmd-shim wrapper to extract the underlying .js entry point.
+// npm shim wrappers end with: "%_prog%" "%dp0%\node_modules\...\<cli>.js" %*
+// %* is cmd batch arg pass-through which mangles multi-line / fenced prompts.
+// Bypass cmd entirely by spawning node + the .js directly.
+export function unwrapCmdToJsScript(cmdPath, opts = {}) {
+  const readFile = opts.readFile || readFileSync;
+  const existsFn = opts.existsSyncFn || existsSync;
+  try {
+    const content = readFile(cmdPath, "utf8");
+    const match = content.match(/"%dp0%[\\/]([^"]+\.[cm]?js)"/i);
+    if (!match) return null;
+    const dir = dirname(cmdPath);
+    const jsPath = pathResolve(dir, match[1].replace(/\\/g, "/"));
+    return existsFn(jsPath) ? jsPath : null;
+  } catch {
+    return null;
+  }
+}
+
+export const MODES = Object.freeze({
+  HEADLESS: "headless",
+  INTERACTIVE: "interactive",
+  AUTO: "auto",
+});
+
+function asPrompt(prompt) {
+  return typeof prompt === "string" ? prompt : "";
+}
+
+function pushFlag(args, flag, value) {
+  if (typeof value === "string" && value.length > 0) {
+    args.push(flag, value);
+  }
+}
+
+// #116-C: codex headless 의 argv-inline prompt 가 macOS oh-my-codex hook
+// SessionStart Failed 회귀를 유발 (codex CLI v0.130.0). cli-adapter-base 의
+// buildExecCommand 가 shell command 형태에서 동일 fix 를 적용했고
+// (TFX_CODEX_STDIN_PROMPT=0 opt-out), 본 함수의 spawn-args 형태에서도 같은
+// 정신으로 prompt 를 stdin transport 로 분리한다. 동일 env var 를 재사용해
+// 사용자가 한 곳만 끄면 양쪽 path 모두 비활성.
+export function resolveStdinPromptMode(explicit, envSource) {
+  if (typeof explicit === "boolean") return explicit;
+  const env = (envSource || process.env).TFX_CODEX_STDIN_PROMPT;
+  if (env === "0" || env === "false") return false;
+  return true;
+}
+
+function normalizeCli(cli) {
+  const value = String(cli || "codex").toLowerCase();
+  if (value === "gemini" || value === "antigravity" || value === "agy") {
+    return "antigravity";
+  }
+  return value;
+}
+
+export function resolveCliExecutable(cli, opts = {}) {
+  const name = String(cli || "codex");
+  const resolveCommand = opts.resolveCommand || whichCommand;
+  const resolved = resolveCommand(name) || name;
+
+  // Windows: Node spawn({ shell: false }) calls CreateProcess directly and does NOT
+  // search PATHEXT. npm-installed CLIs (codex, gemini) live at `<npm>/codex` (Git Bash
+  // shell script) alongside `<npm>/codex.cmd` (Windows batch wrapper). whichCommand
+  // returns the extensionless path, which Windows cannot execute → ENOENT "The system
+  // cannot find the file specified." Append the correct extension when the resolved
+  // path has none.
+  const platform = opts.platform || process.platform;
+  if (platform === "win32" && resolved) {
+    const hasExt = /\.[^\\/.]+$/.test(resolved);
+    if (!hasExt) {
+      const existsFn = opts.existsSyncFn || existsSync;
+      for (const ext of WIN32_EXT_PRECEDENCE) {
+        const candidate = `${resolved}${ext}`;
+        try {
+          if (existsFn(candidate)) return candidate;
+        } catch {
+          // ignore stat failures, try next extension
+        }
+      }
+    }
+  }
+
+  return resolved;
+}
+
+export function buildSpawnSpecForMode(mode, opts = {}) {
+  const cli = normalizeCli(opts.cli || "codex");
+  const prompt = asPrompt(opts.prompt);
+  const commandName = cli === "antigravity" ? "agy" : cli;
+  const resolvedCommand = resolveCliExecutable(commandName, opts);
+  const platform = opts.platform || process.platform;
+
+  // Node v20.12+ (CVE-2024-27980) rejects spawn of .cmd/.bat files with shell:false
+  // (EINVAL). npm-installed Windows wrappers (e.g. codex.cmd) hit this.
+  //
+  // #128 (BUG-A): the cmd /c wrapper used to be the workaround, but cmd batch
+  // %* arg pass-through mangles multi-line and fenced (```bash) prompts before
+  // they reach the underlying .js. We now unwrap the .cmd to the node script
+  // it launches and spawn `node <script>` directly, bypassing cmd entirely.
+  // Falls back to cmd /c if the .cmd cannot be parsed.
+  const needsCmdWrap =
+    platform === "win32" && /\.(cmd|bat)$/i.test(resolvedCommand);
+  const unwrappedJs = needsCmdWrap
+    ? (opts.unwrapCmdFn || unwrapCmdToJsScript)(resolvedCommand)
+    : null;
+  const wrap = (args) => {
+    if (unwrappedJs) {
+      const nodeBin = opts.nodeExecPath || process.execPath;
+      return { command: nodeBin, args: [unwrappedJs, ...args] };
+    }
+    if (needsCmdWrap) {
+      return { command: "cmd", args: ["/c", resolvedCommand, ...args] };
+    }
+    return { command: resolvedCommand, args };
+  };
+
+  if (cli === "antigravity") {
+    const args = ["--print", "--dangerously-skip-permissions"];
+    return {
+      ...wrap(args),
+      useExec: true,
+      shell: false,
+      stdinPrompt: prompt.length > 0,
+      prompt,
+    };
+  }
+
+  if (mode === MODES.INTERACTIVE || mode === MODES.AUTO) {
+    return { ...wrap([]), useExec: false, shell: false };
+  }
+
+  if (cli === "claude") {
+    const args = [];
+    pushFlag(args, "--model", opts.model);
+    args.push("-p", prompt);
+    return { ...wrap(args), useExec: true, shell: false };
+  }
+
+  const args = [];
+  pushFlag(args, "--profile", opts.profile);
+  args.push(
+    "exec",
+    "--dangerously-bypass-approvals-and-sandbox",
+    "--skip-git-repo-check",
+    "--color",
+    "never",
+  );
+  if (Array.isArray(opts.mcpServers)) {
+    for (const server of opts.mcpServers) {
+      args.push("-c", `mcp_servers.${server}.enabled=true`);
+    }
+  }
+
+  // #116-C: codex headless 의 argv-inline prompt → macOS oh-my-codex hook
+  // SessionStart Failed 회귀 (codex v0.130.0). default 가 stdin transport.
+  // conductor.respawnSession 이 spec.prompt 를 child.stdin.write 로 주입한다.
+  const useStdin =
+    resolveStdinPromptMode(opts.stdinPrompt, opts.env) && prompt.length > 0;
+  if (useStdin) {
+    return {
+      ...wrap(args),
+      useExec: true,
+      shell: false,
+      stdinPrompt: true,
+      prompt,
+    };
+  }
+
+  args.push(prompt);
+  return { ...wrap(args), useExec: true, shell: false };
+}
+
+/**
+ * @param {{
+ *   cli: "codex"|"gemini"|"antigravity"|"agy"|"claude",
+ *   taskType?: "implement"|"review"|"research"|"test"|"analyze",
+ *   needsInput?: boolean,
+ *   estimatedDuration?: number,
+ *   hasHub?: boolean,
+ * }} opts
+ * @returns {{ mode: string, reason: string }}
+ */
+export function selectExecutionMode(opts = {}) {
+  const {
+    cli: rawCli = "codex",
+    taskType = "research",
+    needsInput = false,
+    estimatedDuration = 0,
+    hasHub = false,
+  } = opts;
+
+  const cli = normalizeCli(rawCli);
+
+  if (!hasHub) {
+    return {
+      mode: MODES.HEADLESS,
+      reason: "interactive mode requires hub; falling back to headless",
+    };
+  }
+
+  if (cli === "antigravity") {
+    return {
+      mode: MODES.HEADLESS,
+      reason: "antigravity CLI uses headless stdin print mode",
+    };
+  }
+
+  if (taskType === "implement" && !needsInput) {
+    return {
+      mode: MODES.HEADLESS,
+      reason: "implementation without expected input fits headless execution",
+    };
+  }
+
+  if (taskType === "review" || taskType === "analyze") {
+    return {
+      mode: MODES.HEADLESS,
+      reason: "review and analyze tasks default to headless execution",
+    };
+  }
+
+  if (needsInput === true) {
+    return {
+      mode: MODES.INTERACTIVE,
+      reason: "task may require operator input during execution",
+    };
+  }
+
+  if (estimatedDuration > 300) {
+    return {
+      mode: MODES.INTERACTIVE,
+      reason: "long-running work benefits from monitored interactive mode",
+    };
+  }
+
+  return {
+    mode: MODES.HEADLESS,
+    reason: "defaulting to headless execution",
+  };
+}
+
+// buildCommandForMode 는 caller 가 없어 제거됨 (v10.20.x). argv-inline 프롬프트와
+// `-s danger-full-access` flag 가 PR #252 의 stdin redirect 패턴과 정합하지
+// 않아 회귀 위험이 있었다. 실제 헤드리스 spawn 은 buildSpawnSpecForMode
+// (conductor.mjs:544) 가 담당하며, 셸 명령 형태가 필요한 경우는
+// hub/cli-adapter-base.mjs:buildExecCommand 를 사용한다.

package/hub/team/extract-completion-payload.mjs

@@ -0,0 +1,110 @@
+// hub/team/extract-completion-payload.mjs — worker stdout tail → completion JSON
+//
+// Two-tier extraction:
+//   1) Sentinel-framed (preferred, #125): worker emits the payload between
+//      `<<<TFX_COMPLETION_BEGIN>>>` and `<<<TFX_COMPLETION_END>>>` markers
+//      that each occupy their own line. If a standalone-line BEGIN is present
+//      but END is missing, this is a deterministic truncation signal and we
+//      return null instead of falling back. Substring matches inside log
+//      lines (e.g. `[debug] saw <<<TFX_COMPLETION_BEGIN>>> earlier`) do NOT
+//      trigger Tier 1 (Codex R1 LOW finding).
+//   2) Brace-scan fallback (legacy, #115): for workers that haven't adopted
+//      the sentinel protocol yet (or for unit fixtures), scan the tail for
+//      the latest `{...}` pair that parses as a JSON object.
+//
+// The hypervisor's F7 guard (validateWorkerCompletion) decides whether the
+// parsed payload is semantically valid — this layer only handles extraction.
+
+import { SENTINEL_BEGIN, SENTINEL_END } from "./sentinel-capture.mjs";
+
+function isLineEdgeChar(ch) {
+  return ch === "\n" || ch === "\r";
+}
+
+function findStandaloneMarkerLast(text, marker) {
+  let from = 0;
+  let last = -1;
+  while (from <= text.length - marker.length) {
+    const idx = text.indexOf(marker, from);
+    if (idx === -1) return last;
+    const before = idx === 0 || isLineEdgeChar(text[idx - 1]);
+    const afterIdx = idx + marker.length;
+    const after = afterIdx === text.length || isLineEdgeChar(text[afterIdx]);
+    if (before && after) last = idx;
+    from = idx + 1;
+  }
+  return last;
+}
+
+function findStandaloneMarkerFrom(text, marker, fromIdx) {
+  let from = fromIdx;
+  while (from <= text.length - marker.length) {
+    const idx = text.indexOf(marker, from);
+    if (idx === -1) return -1;
+    const before = idx === 0 || isLineEdgeChar(text[idx - 1]);
+    const afterIdx = idx + marker.length;
+    const after = afterIdx === text.length || isLineEdgeChar(text[afterIdx]);
+    if (before && after) return idx;
+    from = idx + 1;
+  }
+  return -1;
+}
+
+/**
+ * @param {string} tail raw stdout (sentinel snapshot or 16 KiB sliding tail)
+ * @returns {{payload: object} | null}
+ */
+export function extractCompletionPayload(tail) {
+  if (typeof tail !== "string" || tail.length === 0) return null;
+
+  // Tier 1: sentinel-framed. Use last standalone-line BEGIN so a worker that
+  // emitted multiple payloads (retry, debug log) yields the most recent one.
+  const beginIdx = findStandaloneMarkerLast(tail, SENTINEL_BEGIN);
+  if (beginIdx !== -1) {
+    const innerStart = beginIdx + SENTINEL_BEGIN.length;
+    const endIdx = findStandaloneMarkerFrom(tail, SENTINEL_END, innerStart);
+    if (endIdx === -1) return null; // BEGIN without END → truncation/incomplete
+    const inner = tail.slice(innerStart, endIdx).trim();
+    try {
+      const parsed = JSON.parse(inner);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return { payload: parsed };
+      }
+    } catch {
+      // Sentinel-framed but invalid JSON — do not fall back to brace scan,
+      // because the worker explicitly tried (and failed) to use the protocol.
+    }
+    return null;
+  }
+
+  // Tier 2: brace-scan fallback. Iterate from the latest `}` backward; for
+  // each close, try every `{` that sits before it (nearest first, widening
+  // outward). Tolerates trailing noise containing `}` (`noise } more`) and
+  // dangling `{` (`{ broken`) after the real payload.
+  const closes = [];
+  const opens = [];
+  for (let i = 0; i < tail.length; i += 1) {
+    const ch = tail[i];
+    if (ch === "}") closes.push(i);
+    else if (ch === "{") opens.push(i);
+  }
+  if (closes.length === 0 || opens.length === 0) return null;
+
+  for (let c = closes.length - 1; c >= 0; c -= 1) {
+    const closeIdx = closes[c];
+    for (let o = opens.length - 1; o >= 0; o -= 1) {
+      const openIdx = opens[o];
+      if (openIdx >= closeIdx) continue;
+      const candidate = tail.slice(openIdx, closeIdx + 1);
+      try {
+        const parsed = JSON.parse(candidate);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          return { payload: parsed };
+        }
+      } catch {
+        // try an earlier `{` for this close, then an earlier `}`.
+      }
+    }
+  }
+  return null;
+}

package/hub/team/git-preflight.mjs

@@ -0,0 +1,286 @@
+// hub/team/git-preflight.mjs — Pre-flight safety check for dangerous git ops.
+// Blocks checkout/rebase/cherry-pick/reset/stash-pop/worktree-remove when they
+// would conflict with other active Synapse sessions' dirty files or claimed
+// leases. Fail-open by default: if registry/locks are unavailable, allow the op
+// with a warning (worktree isolation is the baseline safety net).
+
+/**
+ * Factory for git pre-flight check.
+ *
+ * @param {object} opts
+ * @param {{ getActive: () => Array<object> }} opts.registry — synapse-registry duck type
+ * @param {{ snapshot: () => Array<object> }} opts.locks — swarm-locks duck type
+ * @param {boolean} [opts.failOpen=true] — allow op when registry/locks throw or are missing
+ * @param {(level: string, msg: string, data?: object) => void} [opts.logger] — optional logger
+ * @returns {{
+ *   check: Function,
+ *   checkRebase: Function,
+ *   checkCheckout: Function,
+ *   checkCherryPick: Function,
+ *   checkReset: Function,
+ *   checkStashPop: Function,
+ *   checkWorktreeRemove: Function,
+ * }}
+ */
+export function createGitPreflight(opts = {}) {
+  const { registry, locks, failOpen = true, logger = null } = opts;
+
+  function log(level, msg, data) {
+    if (logger) {
+      try {
+        logger(level, msg, data);
+      } catch {
+        /* logger failure is non-fatal */
+      }
+      return;
+    }
+    if (level === "warn") {
+      console.warn(`[git-preflight] ${msg}`, data ?? "");
+    } else if (level === "error") {
+      console.error(`[git-preflight] ${msg}`, data ?? "");
+    }
+  }
+
+  // ── helpers ──────────────────────────────────────────────
+
+  function safeGetActive() {
+    try {
+      const value = registry?.getActive?.();
+      if (!Array.isArray(value)) return null;
+      return value;
+    } catch (err) {
+      log("warn", "registry.getActive threw", { error: err?.message });
+      return null;
+    }
+  }
+
+  function safeSnapshot() {
+    try {
+      const value = locks?.snapshot?.();
+      if (!Array.isArray(value)) return null;
+      return value;
+    } catch (err) {
+      log("warn", "locks.snapshot threw", { error: err?.message });
+      return null;
+    }
+  }
+
+  function failOpenDecision(reason) {
+    log("warn", "hub unavailable, failing open", { reason });
+    return { allowed: true, reason: "hub_unavailable_fail_open" };
+  }
+
+  function normalizeFiles(list) {
+    if (!Array.isArray(list)) return new Set();
+    return new Set(
+      list
+        .filter((f) => typeof f === "string" && f.length > 0)
+        .map((f) => f.replace(/\\/g, "/")),
+    );
+  }
+
+  function otherActiveSessions(active, sessionId) {
+    return active.filter((s) => s?.sessionId && s.sessionId !== sessionId);
+  }
+
+  function otherLeases(snapshot, workerId) {
+    return snapshot.filter(
+      (entry) => entry?.workerId && entry.workerId !== workerId,
+    );
+  }
+
+  function buildConflict(file, session, holder) {
+    return {
+      file,
+      activeSession: session?.sessionId ?? holder ?? "unknown",
+      activeTask: session?.taskSummary ?? "",
+      ...(holder ? { leaseHolder: holder } : {}),
+    };
+  }
+
+  function recommend(conflicts) {
+    if (!conflicts.length) return "";
+    const first = conflicts[0];
+    const owner = first.leaseHolder || first.activeSession;
+    const task = first.activeTask ? ` Active task: '${first.activeTask}'` : "";
+    return `Wait for '${owner}' to finish, or coordinate via HITL.${task}`;
+  }
+
+  function blockedDecision(op, conflicts, extraReason) {
+    return {
+      allowed: false,
+      reason: extraReason || "overlap_with_active_session",
+      conflicts,
+      recommendation: recommend(conflicts),
+      op,
+    };
+  }
+
+  function allowedDecision() {
+    return { allowed: true };
+  }
+
+  // ── shared scanners ─────────────────────────────────────
+
+  function findDirtyFileConflicts(sessionId, workerId) {
+    const active = safeGetActive();
+    const snapshot = safeSnapshot();
+
+    if (active == null || snapshot == null) {
+      return failOpen ? { fallOpen: true } : { fallOpen: false, conflicts: [] };
+    }
+
+    const conflicts = [];
+    const seen = new Set();
+
+    for (const session of otherActiveSessions(active, sessionId)) {
+      const dirty = normalizeFiles(session.dirtyFiles);
+      for (const file of dirty) {
+        if (seen.has(file)) continue;
+        seen.add(file);
+        conflicts.push(buildConflict(file, session));
+      }
+    }
+
+    for (const lease of otherLeases(snapshot, workerId)) {
+      if (lease.leaseType && lease.leaseType !== "exclusive") continue;
+      const file = typeof lease.file === "string" ? lease.file : null;
+      if (!file || seen.has(file)) continue;
+      seen.add(file);
+      const sessionMeta = lease.sessionMeta || null;
+      conflicts.push(
+        buildConflict(
+          file,
+          sessionMeta
+            ? {
+                sessionId: sessionMeta.sessionId || lease.workerId,
+                taskSummary: sessionMeta.taskSummary || "",
+              }
+            : null,
+          lease.workerId,
+        ),
+      );
+    }
+
+    return { conflicts };
+  }
+
+  function findTargetFileConflicts(targetFiles, sessionId, workerId) {
+    const active = safeGetActive();
+    const snapshot = safeSnapshot();
+
+    if (active == null || snapshot == null) {
+      return failOpen ? { fallOpen: true } : { fallOpen: false, conflicts: [] };
+    }
+
+    const targets = normalizeFiles(targetFiles);
+    if (targets.size === 0) return { conflicts: [] };
+
+    const conflicts = [];
+    const seen = new Set();
+
+    for (const session of otherActiveSessions(active, sessionId)) {
+      const dirty = normalizeFiles(session.dirtyFiles);
+      for (const file of dirty) {
+        if (!targets.has(file) || seen.has(file)) continue;
+        seen.add(file);
+        conflicts.push(buildConflict(file, session));
+      }
+    }
+
+    for (const lease of otherLeases(snapshot, workerId)) {
+      if (lease.leaseType && lease.leaseType !== "exclusive") continue;
+      const file = typeof lease.file === "string" ? lease.file : null;
+      if (!file || !targets.has(file) || seen.has(file)) continue;
+      seen.add(file);
+      const sessionMeta = lease.sessionMeta || null;
+      conflicts.push(
+        buildConflict(
+          file,
+          sessionMeta
+            ? {
+                sessionId: sessionMeta.sessionId || lease.workerId,
+                taskSummary: sessionMeta.taskSummary || "",
+              }
+            : null,
+          lease.workerId,
+        ),
+      );
+    }
+
+    return { conflicts };
+  }
+
+  // ── public API ──────────────────────────────────────────
+
+  /**
+   * Core pre-flight check.
+   *
+   * @param {"checkout"|"rebase"|"cherry-pick"|"reset"|"stash-pop"|"worktree-remove"} op
+   * @param {{ targetFiles?: string[], branch?: string, ref?: string, worktreePath?: string }} args
+   * @param {{ sessionId: string, workerId?: string }} sessionContext
+   * @returns {{ allowed: boolean, reason?: string, conflicts?: object[], recommendation?: string, op?: string }}
+   */
+  function check(op, args = {}, sessionContext = {}) {
+    const sessionId = sessionContext.sessionId || "";
+    const workerId = sessionContext.workerId || sessionId;
+
+    switch (op) {
+      case "checkout":
+      case "rebase":
+      case "reset":
+      case "stash-pop": {
+        const res = findDirtyFileConflicts(sessionId, workerId);
+        if (res.fallOpen) return failOpenDecision(op);
+        if (res.conflicts.length > 0) return blockedDecision(op, res.conflicts);
+        return allowedDecision();
+      }
+      case "cherry-pick": {
+        const targets = Array.isArray(args.targetFiles) ? args.targetFiles : [];
+        const res = findTargetFileConflicts(targets, sessionId, workerId);
+        if (res.fallOpen) return failOpenDecision(op);
+        if (res.conflicts.length > 0) return blockedDecision(op, res.conflicts);
+        return allowedDecision();
+      }
+      case "worktree-remove": {
+        const active = safeGetActive();
+        if (active == null) return failOpenDecision(op);
+        const target =
+          typeof args.worktreePath === "string"
+            ? args.worktreePath.replace(/\\/g, "/")
+            : "";
+        if (!target) return allowedDecision();
+        const conflicts = [];
+        for (const session of otherActiveSessions(active, sessionId)) {
+          const sessionPath =
+            typeof session.worktreePath === "string"
+              ? session.worktreePath.replace(/\\/g, "/")
+              : "";
+          if (sessionPath && sessionPath === target) {
+            conflicts.push({
+              file: target,
+              activeSession: session.sessionId,
+              activeTask: session.taskSummary || "",
+            });
+          }
+        }
+        if (conflicts.length > 0) {
+          return blockedDecision(op, conflicts, "active_worktree");
+        }
+        return allowedDecision();
+      }
+      default:
+        return allowedDecision();
+    }
+  }
+
+  return Object.freeze({
+    check,
+    checkRebase: (args, ctx) => check("rebase", args, ctx),
+    checkCheckout: (args, ctx) => check("checkout", args, ctx),
+    checkCherryPick: (args, ctx) => check("cherry-pick", args, ctx),
+    checkReset: (args, ctx) => check("reset", args, ctx),
+    checkStashPop: (args, ctx) => check("stash-pop", args, ctx),
+    checkWorktreeRemove: (args, ctx) => check("worktree-remove", args, ctx),
+  });
+}