@triflux/remote 10.50.2 → 10.51.0

package/hub/team/swarm-locks.mjs

@@ -1,335 +0,0 @@
-// hub/team/swarm-locks.mjs — File-level lease lock manager for swarm execution
-// Prevents multiple workers from writing to the same file simultaneously.
-// Lock state is kept in-memory (single-process hypervisor) with optional
-// JSON persistence to .triflux/swarm-locks.json for crash recovery.
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, relative, resolve } from "node:path";
-import { DEFAULT_SWARM_LOCK_TTL_MS } from "@triflux/core/hub/lib/timeout-defaults.mjs";
-
-const LOCK_TTL_MS = DEFAULT_SWARM_LOCK_TTL_MS;
-
-// Distribution-critical paths. A swarm worker that modifies these without
-// having them explicitly listed in its shard lease is almost certainly a
-// recovery-patch fallout (worker exited before commit, hypervisor saved
-// patch with destructive `+++ /dev/null` deletions). Block by default;
-// override via validateChanges options.sensitiveDeny.
-//
-// Paths use POSIX separators (matches normalizePath output).
-export const SENSITIVE_PATH_PREFIXES = [
-  ".claude-plugin/",
-  "bin/",
-  ".github/workflows/",
-];
-export const SENSITIVE_PATH_FILES = [
-  ".gitignore",
-  ".npmignore",
-  "package.json",
-  "package-lock.json",
-  "biome.json",
-];
-
-export const DEFAULT_SENSITIVE_DENY = Object.freeze({
-  prefixes: Object.freeze([...SENSITIVE_PATH_PREFIXES]),
-  files: Object.freeze([...SENSITIVE_PATH_FILES]),
-});
-
-/**
- * Swarm lock manager factory.
- * @param {object} [opts]
- * @param {string} [opts.repoRoot] — repository root for relative path normalization
- * @param {string} [opts.persistPath] — JSON file path for crash recovery persistence
- * @param {number} [opts.ttlMs=600000] — lock TTL in ms (auto-expire stale locks)
- * @returns {SwarmLockManager}
- */
-export function createSwarmLocks(opts = {}) {
-  const { repoRoot = process.cwd(), persistPath, ttlMs = LOCK_TTL_MS } = opts;
-
-  /** @type {Map<string, LockEntry>} normalized relative path → lock */
-  const locks = new Map();
-
-  // ── helpers ──────────────────────────────────────────────────
-
-  function normalizePath(filePath) {
-    const abs = resolve(repoRoot, filePath);
-    return relative(repoRoot, abs).replace(/\\/g, "/");
-  }
-
-  function now() {
-    return Date.now();
-  }
-
-  function normalizeLeaseType(leaseType) {
-    return leaseType === "shared-read" ? "shared-read" : "exclusive";
-  }
-
-  function normalizeSessionMeta(sessionMeta) {
-    return sessionMeta ?? null;
-  }
-
-  function normalizeEntry(entry) {
-    return {
-      workerId: entry.workerId,
-      acquiredAt: entry.acquiredAt,
-      leaseType: normalizeLeaseType(entry.leaseType),
-      sessionMeta: normalizeSessionMeta(entry.sessionMeta),
-    };
-  }
-
-  function hasConflict(existing, requesterId, requestedLeaseType) {
-    if (!existing || existing.workerId === requesterId) return false;
-    if (
-      existing.leaseType === "shared-read" &&
-      requestedLeaseType === "shared-read"
-    ) {
-      return false;
-    }
-    return true;
-  }
-
-  function isExpired(entry) {
-    return now() - entry.acquiredAt > ttlMs;
-  }
-
-  function pruneExpired() {
-    for (const [path, entry] of locks) {
-      if (isExpired(entry)) locks.delete(path);
-    }
-  }
-
-  // ── persistence ─────────────────────────────────────────────
-
-  function persist() {
-    if (!persistPath) return;
-    try {
-      mkdirSync(dirname(persistPath), { recursive: true });
-      const data = Object.fromEntries(
-        [...locks].map(([k, v]) => [k, { ...v }]),
-      );
-      writeFileSync(persistPath, JSON.stringify(data, null, 2), "utf8");
-    } catch {
-      /* best-effort */
-    }
-  }
-
-  function restore() {
-    if (!persistPath || !existsSync(persistPath)) return;
-    try {
-      const data = JSON.parse(readFileSync(persistPath, "utf8"));
-      const ts = now();
-      for (const [path, entry] of Object.entries(data)) {
-        if (ts - entry.acquiredAt <= ttlMs) {
-          locks.set(path, normalizeEntry(entry));
-        }
-      }
-    } catch {
-      /* corrupted file — start fresh */
-    }
-  }
-
-  // restore on creation
-  restore();
-
-  // ── public API ──────────────────────────────────────────────
-
-  /**
-   * Acquire file leases for a worker.
-   * @param {string} workerId — worker/shard identifier
-   * @param {string[]} files — file paths to lock
-   * @param {{ leaseType?: "exclusive" | "shared-read", sessionMeta?: { sessionId: string, host: string, taskSummary: string } }} [opts]
-   * @returns {{ ok: boolean, acquired: string[], conflicts: Array<{ file: string, holder: string }> }}
-   */
-  function acquire(workerId, files, opts = {}) {
-    pruneExpired();
-
-    const leaseType = normalizeLeaseType(opts.leaseType);
-    const sessionMeta = normalizeSessionMeta(opts.sessionMeta);
-    const normalized = files.map((f) => normalizePath(f));
-    const conflicts = [];
-    const toAcquire = [];
-    const allowedSharedRead = [];
-
-    for (let i = 0; i < normalized.length; i++) {
-      const path = normalized[i];
-      const existing = locks.get(path);
-
-      if (!existing || isExpired(existing)) {
-        toAcquire.push(path);
-        continue;
-      }
-
-      if (hasConflict(existing, workerId, leaseType)) {
-        conflicts.push({ file: files[i], holder: existing.workerId });
-      } else {
-        if (
-          !(
-            existing.workerId !== workerId &&
-            existing.leaseType === "shared-read" &&
-            leaseType === "shared-read"
-          )
-        ) {
-          toAcquire.push(path);
-        } else {
-          allowedSharedRead.push(path);
-        }
-      }
-    }
-
-    if (conflicts.length > 0) {
-      return { ok: false, acquired: [], conflicts };
-    }
-
-    const ts = now();
-    for (const path of toAcquire) {
-      locks.set(path, { workerId, acquiredAt: ts, leaseType, sessionMeta });
-    }
-
-    persist();
-    return {
-      ok: true,
-      acquired: [...toAcquire, ...allowedSharedRead],
-      conflicts: [],
-    };
-  }
-
-  /**
-   * Release all locks held by a worker.
-   * @param {string} workerId
-   * @returns {number} number of locks released
-   */
-  function release(workerId) {
-    let count = 0;
-    for (const [path, entry] of locks) {
-      if (entry.workerId === workerId) {
-        locks.delete(path);
-        count += 1;
-      }
-    }
-    if (count > 0) persist();
-    return count;
-  }
-
-  function renew(workerId) {
-    pruneExpired();
-    const ts = now();
-    let count = 0;
-    for (const entry of locks.values()) {
-      if (entry.workerId === workerId) {
-        entry.acquiredAt = ts;
-        count += 1;
-      }
-    }
-    if (count > 0) persist();
-    return count;
-  }
-
-  /**
-   * Check if a file write would violate any lease.
-   * @param {string} workerId — the worker attempting the write
-   * @param {string} filePath — the file being written
-   * @param {"exclusive" | "shared-read"} [leaseType="exclusive"] — requested lease type
-   * @returns {{ allowed: boolean, holder?: string }}
-   */
-  function check(workerId, filePath, leaseType = "exclusive") {
-    pruneExpired();
-    const path = normalizePath(filePath);
-    const entry = locks.get(path);
-    const normalizedLeaseType = normalizeLeaseType(leaseType);
-
-    if (!entry || isExpired(entry)) return { allowed: true };
-    if (!hasConflict(entry, workerId, normalizedLeaseType))
-      return { allowed: true };
-    return { allowed: false, holder: entry.workerId };
-  }
-
-  /**
-   * Validate a set of changed files against the lease map.
-   * Returns all violations found.
-   *
-   * Beyond the basic cross-lease check, when `options.ownLease` is supplied
-   * (the caller's known lease set), this also flags out-of-lease writes to
-   * distribution-critical paths — e.g. recovery-patch fallouts where a
-   * worker's recorded diff carries `+++ /dev/null` deletions of files like
-   * `.claude-plugin/marketplace.json` (regression of #115 / #34).
-   *
-   * `options.ownLease` is opt-in to preserve existing callers; when omitted,
-   * legacy behavior (cross-lease check only) is kept.
-   *
-   * @param {string} workerId
-   * @param {string[]} changedFiles
-   * @param {{ ownLease?: string[], sensitiveDeny?: { prefixes?: string[], files?: string[] } }} [options]
-   * @returns {Array<{ file: string, holder?: string, kind: "other-lease" | "sensitive-out-of-lease" }>}
-   */
-  function validateChanges(workerId, changedFiles, options = {}) {
-    pruneExpired();
-    const violations = [];
-    const ownLeaseSet = Array.isArray(options.ownLease)
-      ? new Set(options.ownLease.map((path) => normalizePath(path)))
-      : null;
-    const sensitivePrefixes =
-      options.sensitiveDeny?.prefixes ?? SENSITIVE_PATH_PREFIXES;
-    const sensitiveFiles = new Set(
-      options.sensitiveDeny?.files ?? SENSITIVE_PATH_FILES,
-    );
-
-    for (const file of changedFiles) {
-      const path = normalizePath(file);
-      const entry = locks.get(path);
-
-      if (entry && entry.workerId !== workerId && !isExpired(entry)) {
-        violations.push({ file, holder: entry.workerId, kind: "other-lease" });
-        continue;
-      }
-
-      // Sensitive-path guard only runs when caller supplied ownLease.
-      // We only flag when the worker did NOT explicitly lease the file —
-      // an explicit lease means the shard intentionally owns it.
-      if (ownLeaseSet && !ownLeaseSet.has(path)) {
-        const isSensitive =
-          sensitiveFiles.has(path) ||
-          sensitivePrefixes.some((prefix) => path.startsWith(prefix));
-        if (isSensitive) {
-          violations.push({ file, kind: "sensitive-out-of-lease" });
-        }
-      }
-    }
-
-    return violations;
-  }
-
-  /**
-   * Get snapshot of all active locks.
-   * @returns {Array<{ file: string, workerId: string, acquiredAt: number, leaseType: "exclusive" | "shared-read", sessionMeta: { sessionId: string, host: string, taskSummary: string } | null }>}
-   */
-  function snapshot() {
-    pruneExpired();
-    return [...locks].map(([file, entry]) => ({
-      file,
-      workerId: entry.workerId,
-      acquiredAt: entry.acquiredAt,
-      leaseType: normalizeLeaseType(entry.leaseType),
-      sessionMeta: normalizeSessionMeta(entry.sessionMeta),
-    }));
-  }
-
-  /**
-   * Release all locks.
-   */
-  function releaseAll() {
-    locks.clear();
-    persist();
-  }
-
-  return Object.freeze({
-    acquire,
-    release,
-    renew,
-    check,
-    validateChanges,
-    snapshot,
-    releaseAll,
-    get size() {
-      return locks.size;
-    },
-  });
-}

package/hub/team/swarm-planner.mjs

@@ -1,371 +0,0 @@
-// hub/team/swarm-planner.mjs — PRD → Swarm execution plan generator
-// Parses a PRD markdown document into shards (units of work), each with:
-//   - file-lease-map: files the shard is allowed to modify
-//   - MCP manifest: MCP servers the shard needs
-//   - mergeOrder: topological order for integrating results
-//
-// PRD format expected:
-//   ## Shard: <name>
-//   - agent: codex|gemini|claude
-//   - files: path/a.mjs, path/b.mjs
-//   - mcp: server1, server2
-//   - depends: shard-name-1, shard-name-2
-//   - critical: true|false
-//   - redundancy: false|fallback|true|same-cli
-//   - prompt: |
-//       multi-line prompt text
-
-import { readFileSync } from "node:fs";
-import { selectHostForCapability } from "@triflux/core/hub/lib/ssh-command.mjs";
-
-/** Shard schema defaults */
-const SHARD_DEFAULTS = Object.freeze({
-  agent: "codex",
-  files: [],
-  mcp: [],
-  depends: [],
-  critical: false,
-  redundancy: false,
-  prompt: "",
-  host: "",
-});
-
-/**
- * Parse a PRD markdown into shard definitions.
- * @param {string} content — PRD markdown content
- * @returns {Shard[]}
- */
-export function parseShards(content) {
-  const lines = content.split(/\r?\n/);
-  const shards = [];
-  let current = null;
-  let inPrompt = false;
-  let promptLines = [];
-
-  function flushPrompt() {
-    if (current && promptLines.length > 0) {
-      current.prompt = promptLines.join("\n").trim();
-      promptLines = [];
-    }
-    inPrompt = false;
-  }
-
-  function flushShard() {
-    flushPrompt();
-    if (current) {
-      shards.push({ ...SHARD_DEFAULTS, ...current });
-      current = null;
-    }
-  }
-
-  for (const line of lines) {
-    // New shard header: ## Shard: <name>
-    const shardMatch = line.match(/^##\s+Shard:\s*(.+)$/i);
-    if (shardMatch) {
-      flushShard();
-      current = { name: shardMatch[1].trim() };
-      continue;
-    }
-
-    // Non-shard heading ends current shard (e.g. ## Notes)
-    if (/^##\s+/.test(line) && !line.match(/^##\s+Shard:/i)) {
-      flushShard();
-      continue;
-    }
-
-    if (!current) continue;
-
-    // Prompt block continuation
-    if (inPrompt) {
-      if (/^- \w+:/i.test(line)) {
-        flushPrompt();
-        // fall through to field parsing
-      } else {
-        promptLines.push(line);
-        continue;
-      }
-    }
-
-    // Field parsing: - key: value
-    const fieldMatch = line.match(/^-\s+(\w+):\s*(.*)$/i);
-    if (!fieldMatch) continue;
-
-    const [, key, rawValue] = fieldMatch;
-    const value = rawValue.trim();
-
-    switch (key.toLowerCase()) {
-      case "agent":
-        current.agent = value.toLowerCase();
-        break;
-      case "files":
-        current.files = value
-          .split(/,\s*/)
-          .map((f) => f.trim())
-          .filter(Boolean);
-        break;
-      case "mcp":
-        current.mcp = value
-          .split(/,\s*/)
-          .map((s) => s.trim())
-          .filter(Boolean);
-        break;
-      case "depends":
-        current.depends = value
-          .split(/,\s*/)
-          .map((d) => d.trim())
-          .filter(Boolean)
-          .filter(
-            (d) => !["none", "-", "—", "n/a", "없음"].includes(d.toLowerCase()),
-          );
-        break;
-      case "critical":
-        current.critical = /^(true|yes|1)$/i.test(value);
-        break;
-      case "redundancy":
-        if (/^(true|yes|1|fallback)$/i.test(value)) {
-          current.redundancy = "fallback";
-        } else if (/^(same-cli|same_cli|same|primary)$/i.test(value)) {
-          current.redundancy = "same-cli";
-        } else {
-          current.redundancy = false;
-        }
-        break;
-      case "host":
-        current.host = value;
-        break;
-      case "prompt":
-        if (value && !value.startsWith("|")) {
-          current.prompt = value;
-        } else {
-          inPrompt = true;
-          promptLines = [];
-        }
-        break;
-      default:
-        // store unknown fields as-is
-        current[key] = value;
-    }
-  }
-
-  flushShard();
-  return shards;
-}
-
-/**
- * Build file-lease-map from shards.
- * Maps each shard name to its allowed files.
- * Detects conflicting file assignments across shards.
- * @param {Shard[]} shards
- * @returns {{ leaseMap: Map<string, string[]>, conflicts: Array<{ file: string, shards: string[] }> }}
- */
-export function buildFileLeaseMap(shards) {
-  const leaseMap = new Map();
-  const fileOwners = new Map(); // file → [shard names]
-
-  for (const shard of shards) {
-    leaseMap.set(shard.name, [...shard.files]);
-    for (const file of shard.files) {
-      const owners = fileOwners.get(file) || [];
-      owners.push(shard.name);
-      fileOwners.set(file, owners);
-    }
-  }
-
-  const conflicts = [];
-  for (const [file, owners] of fileOwners) {
-    if (owners.length > 1) {
-      conflicts.push({ file, shards: owners });
-    }
-  }
-
-  return { leaseMap, conflicts };
-}
-
-/**
- * Build MCP manifest from shards.
- * Maps each shard name to its required MCP servers.
- * @param {Shard[]} shards
- * @returns {Map<string, string[]>}
- */
-export function buildMcpManifest(shards) {
-  const manifest = new Map();
-  for (const shard of shards) {
-    manifest.set(shard.name, [...shard.mcp]);
-  }
-  return manifest;
-}
-
-/**
- * Compute topological merge order based on shard dependencies.
- * @param {Shard[]} shards
- * @returns {{ order: string[], cycles: string[][] }}
- */
-export function computeMergeOrder(shards) {
-  const nameSet = new Set(shards.map((s) => s.name));
-  const adj = new Map(); // name → [dependents]
-  const inDeg = new Map(); // name → number
-
-  for (const shard of shards) {
-    adj.set(shard.name, []);
-    inDeg.set(shard.name, 0);
-  }
-
-  for (const shard of shards) {
-    for (const dep of shard.depends) {
-      if (!nameSet.has(dep)) continue; // ignore unknown deps
-      adj.get(dep).push(shard.name);
-      inDeg.set(shard.name, inDeg.get(shard.name) + 1);
-    }
-  }
-
-  // Kahn's algorithm
-  const queue = [];
-  for (const [name, deg] of inDeg) {
-    if (deg === 0) queue.push(name);
-  }
-
-  const order = [];
-  while (queue.length > 0) {
-    // stable sort: alphabetical among same-level nodes
-    queue.sort();
-    const node = queue.shift();
-    order.push(node);
-
-    for (const next of adj.get(node)) {
-      const newDeg = inDeg.get(next) - 1;
-      inDeg.set(next, newDeg);
-      if (newDeg === 0) queue.push(next);
-    }
-  }
-
-  // Detect cycles (nodes not in order)
-  const cycles = [];
-  if (order.length < shards.length) {
-    const remaining = shards
-      .filter((s) => !order.includes(s.name))
-      .map((s) => s.name);
-    cycles.push(remaining);
-  }
-
-  return { order, cycles };
-}
-
-/**
- * Full planning pipeline: parse PRD → build plan.
- * @param {string} prdPath — path to PRD markdown file
- * @param {object} [opts]
- * @param {string} [opts.content] — PRD content (if provided, prdPath is ignored)
- * @returns {SwarmPlan}
- */
-export function planSwarm(prdPath, opts = {}) {
-  const content = opts.content || readFileSync(prdPath, "utf8");
-  const shards = parseShards(content);
-
-  if (shards.length === 0) {
-    throw new Error(
-      'No shards found in PRD. Expected "## Shard: <name>" sections.',
-    );
-  }
-
-  const emptyPromptShards = shards.filter(
-    (s) => !s.prompt || s.prompt.trim() === "",
-  );
-  if (emptyPromptShards.length > 0) {
-    const names = emptyPromptShards.map((s) => s.name).join(", ");
-    throw new Error(
-      `Shard(s) with empty prompt: ${names}. ` +
-        `Each shard must include a non-empty "- prompt: |" block. ` +
-        `See docs/prd/_template.md for PRD format.`,
-    );
-  }
-
-  const { leaseMap, conflicts } = buildFileLeaseMap(shards);
-  const mcpManifest = buildMcpManifest(shards);
-  const { order: mergeOrder, cycles } = computeMergeOrder(shards);
-
-  if (cycles.length > 0) {
-    throw new Error(`Dependency cycle detected: ${cycles[0].join(" → ")}`);
-  }
-
-  // Auto-remote suggestion: PRD에 host 미지정 shard가 있고,
-  // hosts.json에 가용 원격 호스트가 있으면 제안 데이터를 생성한다.
-  const remoteSuggestion = buildRemoteSuggestion(shards, opts.repoRoot);
-
-  return Object.freeze({
-    shards: Object.freeze(shards.map((s) => Object.freeze({ ...s }))),
-    leaseMap,
-    mcpManifest,
-    mergeOrder,
-    conflicts,
-    criticalShards: shards.filter((s) => s.critical).map((s) => s.name),
-    remoteSuggestion,
-  });
-}
-
-/**
- * PRD shard에 host가 없고 원격 호스트가 가용하면 분배 제안을 생성한다.
- * 실제 AskUserQuestion 호출은 스킬(tfx-swarm)에서 수행. 여기는 데이터만.
- * @param {Shard[]} shards
- * @param {string} [repoRoot]
- * @returns {object|null} 제안 데이터 또는 null (제안 없음)
- */
-function buildRemoteSuggestion(shards, repoRoot) {
-  const localShards = shards.filter((s) => !s.host);
-  if (localShards.length === 0) return null; // 모든 shard에 host 지정됨
-
-  // 각 shard의 agent에 대해 가용 원격 호스트 조회
-  const agentTypes = [...new Set(localShards.map((s) => s.agent))];
-  const availableHosts = [];
-
-  for (const agent of agentTypes) {
-    try {
-      const hosts = selectHostForCapability(agent, repoRoot);
-      for (const h of hosts) {
-        if (!availableHosts.find((ah) => ah.name === h.name)) {
-          availableHosts.push(h);
-        }
-      }
-    } catch {
-      // hosts.json 없거나 파싱 실패 → 무시
-    }
-  }
-
-  if (availableHosts.length === 0) return null;
-
-  // 분배 제안: 로컬 shard 중 절반(내림)을 원격에 배치
-  const remoteCount = Math.min(
-    Math.floor(localShards.length / 2),
-    availableHosts.length,
-  );
-  if (remoteCount === 0) return null;
-
-  // 의존성 없는 shard를 우선 원격 후보로 선택
-  const candidates = localShards
-    .filter((s) => s.depends.length === 0)
-    .concat(localShards.filter((s) => s.depends.length > 0));
-
-  const suggested = [];
-  for (let i = 0; i < remoteCount && i < candidates.length; i++) {
-    const shard = candidates[i];
-    const host = availableHosts[i % availableHosts.length];
-    suggested.push({
-      shardName: shard.name,
-      host: host.name,
-      hostDescription: host.config.description,
-      specs: host.specs,
-    });
-  }
-
-  return Object.freeze({
-    localCount: localShards.length - remoteCount,
-    remoteCount,
-    totalShards: shards.length,
-    availableHosts: availableHosts.map((h) => ({
-      name: h.name,
-      description: h.config.description,
-      specs: h.specs,
-      capabilities: h.config.capabilities,
-    })),
-    suggested: Object.freeze(suggested),
-  });
-}