triflux 10.24.0 → 10.25.0

package/bin/triflux.mjs

@@ -61,6 +61,7 @@ import { serializeHandoff } from "../scripts/lib/handoff.mjs";
 import {
   addRegistryServer,
   createDefaultRegistry,
+  discoverProjectMcpTargets,
   inspectRegistry,
   inspectRegistryStatus,
   removeRegistryServer,
@@ -333,7 +334,8 @@ const CLI_COMMAND_SCHEMAS = Object.freeze({
         ],
       },
       sync: {
-        usage: "tfx mcp sync [--json]",
+        usage:
+          "tfx mcp sync [--json] [--all-projects [root]] [--dry-run] [--exclude <glob>]",
         options: [
           {
             name: "--json",
@@ -2515,11 +2517,12 @@ function buildMcpStatusRows(statusInfo) {
     .filter((row) => row.type === "registry")
     .map((row) => {
       let detail = "";
-      if (row.status === "present") detail = row.actualUrl || row.expectedUrl;
+      if (row.status === "present")
+        detail = row.actualUrl || row.actualCommand || row.expectedUrl;
       else if (row.status === "missing") detail = "registry only";
       else if (row.status === "missing-file") detail = "config missing";
       else if (row.status === "mismatch")
-        detail = `expected ${row.expectedUrl}`;
+        detail = `expected ${row.expectedUrl || row.expectedCommand}`;
       else if (row.status === "invalid-config") detail = "parse error";
       else if (row.status === "stdio") detail = "configured as stdio";
       return [
@@ -5776,10 +5779,45 @@ function cmdMcp(args = [], options = {}) {
 
     case "sync": {
       const registryState = ensureValidRegistryState();
-      const result = syncRegistryTargets({ registry: registryState.registry });
+      const allProjectsIndex = args.indexOf("--all-projects");
+      const allProjectsRoot =
+        allProjectsIndex >= 0 &&
+        args[allProjectsIndex + 1] &&
+        !String(args[allProjectsIndex + 1]).startsWith("--")
+          ? args[allProjectsIndex + 1]
+          : null;
+      const dryRun = args.includes("--dry-run");
+      const excludes = args.flatMap((arg, index) =>
+        arg === "--exclude" && args[index + 1] ? [args[index + 1]] : [],
+      );
+      const allProjects =
+        allProjectsIndex >= 0
+          ? discoverProjectMcpTargets({
+              root: allProjectsRoot || undefined,
+              exclude: excludes,
+            })
+          : null;
+      const result = dryRun
+        ? { actions: [] }
+        : syncRegistryTargets({
+            registry: registryState.registry,
+            ...(allProjects ? { targets: allProjects.targets } : {}),
+          });
       if (json) {
         printJson({
           registry_path: registryState.path,
+          ...(allProjects
+            ? {
+                dry_run: dryRun,
+                all_projects: {
+                  root: allProjects.root,
+                  maxDepth: allProjects.maxDepth,
+                  exclude: allProjects.exclude,
+                  count: allProjects.targets.length,
+                },
+                targets: allProjects.targets,
+              }
+            : {}),
           actions: result.actions,
         });
         return;
@@ -5787,8 +5825,22 @@ function cmdMcp(args = [], options = {}) {
 
       console.log(`\n  ${AMBER}${BOLD}⬡ triflux mcp sync${RESET} ${VER}\n`);
       console.log(`  ${LINE}`);
+      if (allProjects) {
+        section("Project Targets");
+        info(`${allProjects.targets.length}개 파일 (${allProjects.root})`);
+        for (const target of allProjects.targets) {
+          info(formatPathForDisplay(target.filePath));
+        }
+        if (dryRun) {
+          console.log("");
+          return;
+        }
+      }
       section("Actions");
       for (const action of result.actions) {
+        for (const warning of action.warnings || []) {
+          process.stderr.write(`${warning}\n`);
+        }
         const label = `${action.label} ${DIM}(${formatPathForDisplay(action.filePath)})${RESET}`;
         if (action.status === "updated") ok(`${label} → updated`);
         else if (action.status === "warning") warn(`${label} → warning`);

package/hub/team/backend.mjs

@@ -1,6 +1,7 @@
 // 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 "../codex-adapter.mjs";
@@ -16,6 +17,22 @@ export function buildGeminiCommand(prompt, resultFile, { isWindows } = {}) {
   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);
 
 // ── 백엔드 클래스 ──────────────────────────────────────────────────────────
@@ -77,19 +94,40 @@ export class ClaudeBackend {
   }
 }
 
+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()],
   ["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) {
@@ -102,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");
@@ -112,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/claude-daemon-control.mjs

@@ -0,0 +1,160 @@
+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 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,
+  });
+}