@triflux/remote 10.0.1 → 10.25.1

package/hub/team/backend.mjs

@@ -1,17 +1,49 @@
 // hub/team/backend.mjs — CLI 백엔드 추상화 레이어
-// 각 CLI(codex/gemini/claude)의 명령 빌드 로직을 클래스로 캡슐화한다.
+// 각 CLI(codex/gemini/claude/antigravity)의 명령 빌드 로직을 클래스로 캡슐화한다.
 // v7.2.2
+import { writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 
 import { buildExecArgs } from "@triflux/core/hub/codex-adapter.mjs";
+import { IS_WINDOWS } from "@triflux/core/hub/platform.mjs";
+
+// --yolo is required: without it gemini waits on stdin for tool-call approval
+// even when stdin is redirected, producing a 0-byte 90s+ silent hang.
+// execution-mode.mjs:buildSpawnSpecForMode enforces the same flag.
+export function buildGeminiCommand(prompt, resultFile, { isWindows } = {}) {
+  if (isWindows) {
+    return `$null | gemini --yolo --prompt ${prompt} --output-format text > '${resultFile}' 2>'${resultFile}.err'`;
+  }
+  return `gemini --yolo --prompt ${prompt} --output-format text > '${resultFile}' 2>'${resultFile}.err' < /dev/null`;
+}
+
+export function buildAntigravityCommand(
+  prompt,
+  resultFile,
+  { isWindows } = {},
+) {
+  // Persist prompt to a sibling file so the shell never interpolates raw
+  // prompt content. Without this the Unix branch let `$()`, backticks, `\\`,
+  // and `"` reach the shell verbatim (P1: shell injection).
+  const promptFile = `${resultFile}.prompt`;
+  writeFileSync(promptFile, prompt);
+  if (isWindows) {
+    return `Get-Content -Raw '${promptFile}' | agy --print --dangerously-skip-permissions > '${resultFile}' 2>'${resultFile}.err'`;
+  }
+  return `agy --print --dangerously-skip-permissions < '${promptFile}' > '${resultFile}' 2>'${resultFile}.err'`;
+}
 
 const _require = createRequire(import.meta.url);
 
 // ── 백엔드 클래스 ──────────────────────────────────────────────────────────
 
 export class CodexBackend {
-  name() { return "codex"; }
-  command() { return "codex"; }
+  name() {
+    return "codex";
+  }
+  command() {
+    return "codex";
+  }
 
   /**
    * @param {string} prompt — 프롬프트 (프롬프트 파일 경로가 아닌 PowerShell 표현식)
@@ -23,44 +55,79 @@ export class CodexBackend {
     return buildExecArgs({ prompt, resultFile, ...opts });
   }
 
-  env() { return {}; }
+  env() {
+    return {};
+  }
 }
 
 export class GeminiBackend {
-  name() { return "gemini"; }
-  command() { return "gemini"; }
+  name() {
+    return "gemini";
+  }
+  command() {
+    return "gemini";
+  }
 
   buildArgs(prompt, resultFile, opts = {}) {
-    return `gemini --prompt ${prompt} --output-format text > '${resultFile}' 2>'${resultFile}.err'`;
+    return buildGeminiCommand(prompt, resultFile, { isWindows: IS_WINDOWS });
   }
 
-  env() { return {}; }
+  env() {
+    return {};
+  }
 }
 
 export class ClaudeBackend {
-  name() { return "claude"; }
-  command() { return "claude"; }
+  name() {
+    return "claude";
+  }
+  command() {
+    return "claude";
+  }
 
   buildArgs(prompt, resultFile, opts = {}) {
     return `claude --print ${prompt} --output-format text > '${resultFile}' 2>&1`;
   }
 
-  env() { return {}; }
+  env() {
+    return {};
+  }
+}
+
+export class AntigravityBackend {
+  name() {
+    return "antigravity";
+  }
+  command() {
+    return "agy";
+  }
+
+  buildArgs(prompt, resultFile, opts = {}) {
+    return buildAntigravityCommand(prompt, resultFile, {
+      isWindows: IS_WINDOWS,
+      ...opts,
+    });
+  }
+
+  env() {
+    return {};
+  }
 }
 
 // ── 레지스트리 ─────────────────────────────────────────────────────────────
 
-/** @type {Map<string, CodexBackend|GeminiBackend|ClaudeBackend>} */
+/** @type {Map<string, CodexBackend|GeminiBackend|ClaudeBackend|AntigravityBackend>} */
 const backends = new Map([
-  ["codex",  new CodexBackend()],
+  ["codex", new CodexBackend()],
   ["gemini", new GeminiBackend()],
   ["claude", new ClaudeBackend()],
+  ["antigravity", new AntigravityBackend()],
 ]);
 
 /**
  * 백엔드 이름으로 조회한다.
- * @param {string} name — "codex" | "gemini" | "claude"
- * @returns {CodexBackend|GeminiBackend|ClaudeBackend}
+ * @param {string} name — "codex" | "gemini" | "claude" | "antigravity"
+ * @returns {CodexBackend|GeminiBackend|ClaudeBackend|AntigravityBackend}
  * @throws {Error} 등록되지 않은 이름
  */
 export function getBackend(name) {
@@ -73,7 +140,7 @@ export function getBackend(name) {
  * 에이전트명 또는 CLI명을 Backend로 해석한다.
  * agent-map.json을 통해 에이전트명 → CLI명으로 변환 후 레지스트리에서 조회한다.
  * @param {string} agentOrCli — "executor", "codex", "designer" 등
- * @returns {CodexBackend|GeminiBackend|ClaudeBackend}
+ * @returns {CodexBackend|GeminiBackend|ClaudeBackend|AntigravityBackend}
  */
 export function getBackendForAgent(agentOrCli) {
   const agentMap = _require("./agent-map.json");
@@ -83,7 +150,7 @@ export function getBackendForAgent(agentOrCli) {
 
 /**
  * 등록된 모든 백엔드를 반환한다.
- * @returns {Array<CodexBackend|GeminiBackend|ClaudeBackend>}
+ * @returns {Array<CodexBackend|GeminiBackend|ClaudeBackend|AntigravityBackend>}
  */
 export function listBackends() {
   return Array.from(backends.values());

package/hub/team/build-worker-prompt.mjs

@@ -0,0 +1,42 @@
+// hub/team/build-worker-prompt.mjs — append Completion Protocol to PRD prompt (#125)
+//
+// swarm-hypervisor injects a Completion Protocol appendix into every worker
+// prompt so that workers emit a sentinel-framed JSON payload conductor.mjs can
+// reliably capture (see sentinel-capture.mjs and extract-completion-payload.mjs).
+//
+// Pure module — no I/O — so the appendix and merge logic can be unit-tested
+// without spawning conductors.
+
+import { SENTINEL_BEGIN, SENTINEL_END } from "./sentinel-capture.mjs";
+
+export const COMPLETION_PROTOCOL_APPENDIX = `
+
+## Completion Protocol (자동 삽입됨)
+<!-- swarm hypervisor 가 이 섹션을 worker prompt 에 자동 주입합니다.
+     PRD 작성자는 이 섹션을 수정하지 마세요.
+     상세: hub/team/build-worker-prompt.mjs / sentinel-capture.mjs (#125). -->
+
+작업의 마지막 단계로, stdout 에 다음 형식의 완료 payload 를 정확히 한 번 출력하라:
+
+${SENTINEL_BEGIN}
+{"shard":"<shard name>","status":"ok","commits_made":[{"sha":"<40-char full sha>","message":"<commit msg>"}]}
+${SENTINEL_END}
+
+규약:
+- 두 sentinel 마커는 각자 자기 줄에 단독으로 출력 (앞뒤 newline)
+- 마커 사이 본문은 단일 JSON object (배열/primitive 금지)
+- commits_made 가 비어 있어도 됨 (no-op shard)
+- 마커 쌍은 stdout 에 정확히 한 번만 출력해야 함. 재emit 시 conductor 는 첫 BEGIN..END 한 쌍만 채택하며, 이후 stdout 은 무시한다.
+- ${SENTINEL_BEGIN} 만 출력하고 ${SENTINEL_END} 누락 시 conductor 가 truncation 으로 명확히 reject
+`;
+
+/**
+ * Append the Completion Protocol section to a PRD prompt.
+ *
+ * @param {string|null|undefined} prdPrompt — original PRD body
+ * @returns {string} prompt with appendix
+ */
+export function buildWorkerPrompt(prdPrompt) {
+  const body = typeof prdPrompt === "string" ? prdPrompt : "";
+  return body + COMPLETION_PROTOCOL_APPENDIX;
+}

package/hub/team/check-mcp-hub.mjs

@@ -0,0 +1,49 @@
+// hub/team/check-mcp-hub.mjs — health-probe L2 용 hub /health ping 체커.
+// health-probe.mjs 의 checkMcp 로 주입되어 `mcp_initializing` state 판정에 사용.
+// hub /health 가 200 이면 OK (MCP transport 인프라 살아있음), 그 외는 fail.
+
+const DEFAULT_HUB_URL = "http://127.0.0.1:27888";
+const DEFAULT_TIMEOUT_MS = 3000;
+
+function resolveHubHealthUrl(hubUrl) {
+  const base = hubUrl || process.env.TFX_HUB_URL || DEFAULT_HUB_URL;
+  // `/mcp` suffix 제거 (triflux convention — bridge.mjs:54, hub-client.mjs,
+  // lead-control.mjs, session-sync.mjs 전부 TFX_HUB_URL 을 MCP transport URL
+  // 로 쓰고 base URL 이 필요할 때 `/mcp$` 를 strip 한다). 제거하지 않으면
+  // `.../mcp/health` 가 되어 hub 가 404 로 응답 → L2 영구 fail → heartbeat
+  // 이 지속적으로 `mcp_initializing` 로 grace — #173 Codex P2 review.
+  return base.replace(/\/mcp\/?$/, "").replace(/\/+$/, "") + "/health";
+}
+
+/**
+ * Hub /health 기반 L2 checker factory.
+ * @param {object} [opts]
+ * @param {string} [opts.hubUrl] — override. 미지정 시 TFX_HUB_URL env 또는 default.
+ * @param {number} [opts.timeoutMs=3000] — fetch timeout (ms).
+ * @param {typeof fetch} [opts.fetchFn] — fetch 오버라이드 (테스트용).
+ * @returns {() => Promise<boolean>} — true = hub healthy, false = degraded/down/timeout.
+ */
+export function createHubHealthChecker(opts = {}) {
+  const url = resolveHubHealthUrl(opts.hubUrl);
+  const timeoutMs = Number.isFinite(opts.timeoutMs)
+    ? opts.timeoutMs
+    : DEFAULT_TIMEOUT_MS;
+  const fetchFn = opts.fetchFn || globalThis.fetch;
+
+  return async function checkMcpHubHealth() {
+    if (typeof fetchFn !== "function") return false;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const res = await fetchFn(url, {
+        method: "GET",
+        signal: controller.signal,
+      });
+      return res.ok === true;
+    } catch {
+      return false;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+}

package/hub/team/claude-daemon-control.mjs

@@ -0,0 +1,219 @@
+import crypto from "node:crypto";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+
+export function resolveClaudeConfigDir(env = process.env) {
+  if (env.CLAUDE_CONFIG_DIR) return path.resolve(env.CLAUDE_CONFIG_DIR);
+  return path.join(os.homedir(), ".claude");
+}
+
+export function deriveClaudeDaemonPaths({
+  configDir = resolveClaudeConfigDir(),
+  uid = typeof process.getuid === "function" ? process.getuid() : 0,
+  tmpRoot = "/tmp",
+} = {}) {
+  const resolvedConfigDir = path.resolve(configDir);
+  const hash = crypto
+    .createHash("sha256")
+    .update(resolvedConfigDir)
+    .digest("hex")
+    .slice(0, 8);
+  const daemonDir = path.join(tmpRoot, `cc-daemon-${uid}`, hash);
+  return {
+    configDir: resolvedConfigDir,
+    hash,
+    daemonDir,
+    controlSock: path.join(daemonDir, "control.sock"),
+    rosterPath: path.join(resolvedConfigDir, "daemon", "roster.json"),
+    sessionsDir: path.join(resolvedConfigDir, "sessions"),
+  };
+}
+
+export function readFirstJsonLine(text) {
+  const line = String(text)
+    .split("\n")
+    .find((entry) => entry.trim().length > 0);
+  if (!line) throw new Error("empty daemon response");
+  return JSON.parse(line);
+}
+
+export function sendClaudeControlRequest(
+  sockPath,
+  request,
+  { timeoutMs = 6000 } = {},
+) {
+  return new Promise((resolve, reject) => {
+    const socket = net.connect(sockPath);
+    let settled = false;
+    let data = "";
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      if (error) reject(error);
+      else resolve(value);
+    };
+
+    socket.setTimeout(timeoutMs, () => {
+      finish(
+        new Error(`Timed out waiting for Claude daemon response: ${sockPath}`),
+      );
+    });
+    socket.on("error", finish);
+    socket.on("connect", () => {
+      socket.write(`${JSON.stringify(request)}\n`);
+    });
+    socket.on("data", (chunk) => {
+      data += chunk.toString("utf8");
+      if (!data.includes("\n")) return;
+      try {
+        finish(null, readFirstJsonLine(data));
+      } catch (error) {
+        finish(error);
+      }
+    });
+    socket.on("close", () => {
+      if (settled) return;
+      if (data.length === 0) {
+        finish(
+          new Error("Claude daemon closed control socket without a response"),
+        );
+        return;
+      }
+      try {
+        finish(null, readFirstJsonLine(data));
+      } catch (error) {
+        finish(error);
+      }
+    });
+  });
+}
+
+export function buildDaemonExecDispatchPayload({
+  short = crypto.randomBytes(4).toString("hex"),
+  sessionId,
+  cwd = process.cwd(),
+  command,
+  name,
+  createdAt = Date.now(),
+  cols = 120,
+  rows = 40,
+} = {}) {
+  if (!command) throw new Error("command is required");
+  if (!name) throw new Error("name is required");
+  const uuid = crypto.randomUUID();
+  const resolvedSessionId = sessionId || `${short}${uuid.slice(8)}`;
+  return {
+    proto: 1,
+    short,
+    sessionId: resolvedSessionId,
+    createdAt,
+    source: "shell",
+    cwd,
+    launch: {
+      mode: "exec",
+      cmd: "/bin/zsh",
+      args: ["-lc", command],
+    },
+    env: {},
+    isolation: "none",
+    respawnFlags: [],
+    seed: {
+      intent: name,
+      name,
+    },
+    cols,
+    rows,
+  };
+}
+
+export function findDaemonJobByShort(listResponse, short) {
+  if (!Array.isArray(listResponse?.jobs)) return null;
+  return listResponse.jobs.find((job) => job?.short === short) || null;
+}
+
+export function findDaemonJobBySessionId(listResponse, sessionId) {
+  if (!Array.isArray(listResponse?.jobs)) return null;
+  const expected = String(sessionId || "");
+  if (!expected) return null;
+  return (
+    listResponse.jobs.find((job) => {
+      const candidate =
+        job?.sessionId ??
+        job?.session_id ??
+        job?.dispatch?.sessionId ??
+        job?.d?.sessionId ??
+        "";
+      return String(candidate) === expected;
+    }) || null
+  );
+}
+
+export async function waitForDaemonJobPid(
+  controlSock,
+  short,
+  { timeoutMs = 5000 } = {},
+) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const list = await sendClaudeControlRequest(controlSock, {
+      proto: 1,
+      op: "list",
+    });
+    const job = findDaemonJobByShort(list, short);
+    if (Number.isInteger(job?.pid) && job.pid > 0) return job;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error(`Claude daemon dispatch did not expose a pid for ${short}`);
+}
+
+export async function killDaemonJob(controlSock, short) {
+  return await sendClaudeControlRequest(controlSock, {
+    proto: 1,
+    op: "kill",
+    short,
+  });
+}
+
+export async function sendKillBySessionId({
+  daemonPaths,
+  sessionId,
+  timeoutMs = 6000,
+} = {}) {
+  const controlSock = daemonPaths?.controlSock;
+  if (!controlSock || !sessionId) {
+    return { ok: true, killed: false, reason: "missing_target" };
+  }
+
+  try {
+    const list = await sendClaudeControlRequest(
+      controlSock,
+      {
+        proto: 1,
+        op: "list",
+      },
+      { timeoutMs },
+    );
+    const job = findDaemonJobBySessionId(list, sessionId);
+    if (!job?.short) {
+      return { ok: true, killed: false, reason: "not_found" };
+    }
+    return await sendClaudeControlRequest(
+      controlSock,
+      {
+        proto: 1,
+        op: "kill",
+        short: job.short,
+      },
+      { timeoutMs },
+    );
+  } catch (error) {
+    return {
+      ok: false,
+      killed: false,
+      reason: "control_unavailable",
+      error: error?.message || String(error),
+    };
+  }
+}