@triflux/core 10.1.0 → 10.26.0

package/hub/gemini-adapter.mjs

@@ -1,41 +1,45 @@
-// hub/gemini-adapter.mjs — Gemini CLI 방어 계층
-// codex-adapter.mjs와 동일 패턴, cli-adapter-base 공통 인터페이스 사용
+// hub/gemini-adapter.mjs — legacy Gemini adapter compatibility layer
+// The "gemini" route is retained as an alias, but execution is Antigravity/agy.
 
-import { mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-import { withRetry } from './workers/worker-utils.mjs';
-import { whichCommandAsync } from './platform.mjs';
+import { mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import {
-  createCircuitBreaker,
-  createResult,
-  appendWarnings,
+  executeWithCircuitBroker,
   normalizePathForShell,
-  shellQuote,
   runProcess,
-} from './cli-adapter-base.mjs';
+} from "./cli-adapter-base.mjs";
+import { whichCommandAsync } from "./platform.mjs";
 
-const breaker = createCircuitBreaker();
+function shellSingleQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
 
-// ── Gemini-specific stall inference ─────────────────────────────
+// ── Antigravity stall inference ─────────────────────────────────
 
 function inferStallMode(stdout, stderr) {
   const text = `${stdout}\n${stderr}`.toLowerCase();
-  if (/(rate.?limit|quota|resource.?exhaust|429)/u.test(text)) return 'rate_limited';
-  if (/(unauthorized|forbidden|auth|login|token|credential|api.?key)/u.test(text)) return 'auth_stall';
-  if (/\bmcp\b|playwright|tavily|brave|sequential|server/u.test(text)) return 'mcp_stall';
-  return 'timeout';
+  if (/(rate.?limit|quota|resource.?exhaust|429)/u.test(text))
+    return "rate_limited";
+  if (
+    /(unauthorized|forbidden|auth|login|token|credential|api.?key)/u.test(text)
+  )
+    return "auth_stall";
+  if (/\bmcp\b|playwright|tavily|brave|sequential|server/u.test(text))
+    return "mcp_stall";
+  return "timeout";
 }
 
 // ── Preflight ───────────────────────────────────────────────────
 
 async function runPreflight(opts = {}) {
-  const geminiPath = await whichCommandAsync('gemini');
-  if (!geminiPath) {
+  const agyPath = await whichCommandAsync("agy");
+  if (!agyPath) {
     return {
-      geminiPath: null,
-      warnings: ['Gemini CLI not found. Install Gemini and ensure `gemini` is available on PATH.'],
+      agyPath: null,
+      warnings: [
+        "Antigravity CLI not found. Install Antigravity and ensure `agy` is available on PATH.",
+      ],
       excludeMcpServers: [],
       ok: false,
     };
@@ -45,38 +49,32 @@ async function runPreflight(opts = {}) {
   const excludeMcpServers = [];
 
   for (const name of Array.isArray(opts.mcpServers) ? opts.mcpServers : []) {
-    const server = String(name ?? '').trim();
+    const server = String(name ?? "").trim();
     if (!server) continue;
-    // Gemini MCP health는 best-effort: 실행 시점에 --allowed-mcp-server-names로 필터링
-    // 사전 probe는 수행하지 않음 (gemini가 자체적으로 graceful degrade)
+    // Antigravity MCP health는 best-effort: 실행 시점 probe는 수행하지 않음.
   }
 
-  return { geminiPath, warnings, excludeMcpServers, ok: true };
+  return { agyPath, warnings, excludeMcpServers, ok: true };
 }
 
 // ── Command building ────────────────────────────────────────────
 
 function buildGeminiCommand(prompt, resultFile, opts = {}) {
-  const parts = ['gemini'];
-
-  if (opts.model) parts.push('--model', shellQuote(opts.model));
-  parts.push('--yolo');
-
-  const allowed = Array.isArray(opts.allowedMcpServers) ? opts.allowedMcpServers : [];
-  const excluded = Array.isArray(opts.excludeMcpServers) ? opts.excludeMcpServers : [];
-  const filtered = allowed.filter((name) => !excluded.includes(name));
-  if (filtered.length) {
-    parts.push('--allowed-mcp-server-names', ...filtered.map((n) => shellQuote(n)));
-  }
-
-  parts.push('--prompt', shellQuote(prompt));
-  parts.push('--output-format', 'text');
+  const parts = [
+    "printf",
+    "%s",
+    shellSingleQuote(prompt),
+    "|",
+    "agy",
+    "--print",
+    "--dangerously-skip-permissions",
+  ];
 
   if (resultFile) {
-    return `${parts.join(' ')} > ${shellQuote(normalizePathForShell(resultFile))} 2>${shellQuote(normalizePathForShell(resultFile + '.err'))}`;
+    return `${parts.join(" ")} > ${shellSingleQuote(normalizePathForShell(resultFile))} 2>${shellSingleQuote(normalizePathForShell(resultFile + ".err"))}`;
   }
 
-  return parts.join(' ');
+  return parts.join(" ");
 }
 
 function buildAttempts(opts, preflight) {
@@ -84,20 +82,19 @@ function buildAttempts(opts, preflight) {
   const base = {
     timeout,
     model: opts.model,
-    allowedMcpServers: Array.isArray(opts.mcpServers) ? [...opts.mcpServers] : [],
+    allowedMcpServers: Array.isArray(opts.mcpServers)
+      ? [...opts.mcpServers]
+      : [],
     excludeMcpServers: [...(preflight.excludeMcpServers || [])],
   };
   if (opts.retryOnFail === false) return [base];
-  return [
-    base,
-    { ...base, timeout: timeout * 2, allowedMcpServers: [] },
-  ];
+  return [base, { ...base, timeout: timeout * 2, allowedMcpServers: [] }];
 }
 
 // ── Public: buildExecArgs ───────────────────────────────────────
 
 export function buildExecArgs(opts = {}) {
-  const prompt = typeof opts.prompt === 'string' ? opts.prompt : '';
+  const prompt = typeof opts.prompt === "string" ? opts.prompt : "";
   return buildGeminiCommand(prompt, opts.resultFile || null, {
     model: opts.model,
     allowedMcpServers: opts.mcpServers,
@@ -106,75 +103,52 @@ export function buildExecArgs(opts = {}) {
 
 // ── Execution ───────────────────────────────────────────────────
 
-async function runGemini(prompt, workdir, preflight, attempt) {
-  const dir = join(tmpdir(), 'triflux-gemini-exec');
+async function runGemini(prompt, workdir, preflight, attempt, lease) {
+  const dir = join(tmpdir(), "triflux-antigravity-exec");
   mkdirSync(dir, { recursive: true });
-  const resultFile = join(dir, `gemini-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
+  const resultFile = join(
+    dir,
+    `agy-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`,
+  );
   const command = buildGeminiCommand(prompt, resultFile, {
     model: attempt.model,
     allowedMcpServers: attempt.allowedMcpServers,
     excludeMcpServers: attempt.excludeMcpServers,
   });
-  return runProcess(command, workdir, attempt.timeout, { resultFile, inferStallMode });
+  // PRD A1: lease.env 가 있으면 spawn env 에 적용 (예: GOOGLE_API_KEY 등 account-specific
+  // 환경변수). lease 가 null 이면 default 동작 유지 (부모 env inherit).
+  const spawnEnv =
+    lease?.env && typeof lease.env === "object"
+      ? { ...process.env, ...lease.env }
+      : undefined;
+  return runProcess(command, workdir, attempt.timeout, {
+    resultFile,
+    inferStallMode,
+    spawnEnv,
+  });
 }
 
 // ── Public API ──────────────────────────────────────────────────
 
-export function getCircuitState(now) {
-  return breaker.getState(now);
+export async function getCircuitState() {
+  const brokerMod = await import("./account-broker.mjs");
+  if (!brokerMod.broker) return { state: "closed", failures: [] };
+  const snap = brokerMod.broker
+    .snapshot()
+    .filter((a) => a.provider === "gemini");
+  return snap.length
+    ? { state: snap[0].circuitState, accounts: snap }
+    : { state: "closed", failures: [] };
 }
 
-export async function execute(opts = {}) {
-  const entry = breaker.canExecute();
-  if (!entry.allowed) {
-    return createResult(false, { fellBack: true, failureMode: 'circuit_open' });
-  }
-
-  const preflight = await runPreflight({ mcpServers: opts.mcpServers });
-  if (!preflight.ok) {
-    breaker.clearTrial();
-    breaker.recordFailure(entry.halfOpen);
-    return createResult(false, {
-      stderr: appendWarnings('', preflight.warnings),
-      fellBack: opts.fallbackToClaude !== false,
-      failureMode: 'crash',
-    });
-  }
-
-  const attempts = buildAttempts(opts, preflight);
-  let attemptIndex = 0;
-  let lastResult = createResult(false);
-
-  try {
-    lastResult = await withRetry(async () => {
-      const result = await runGemini(opts.prompt || '', opts.workdir || process.cwd(), preflight, attempts[attemptIndex]);
-      const current = { ...result, stderr: appendWarnings(result.stderr, preflight.warnings), retried: attemptIndex > 0 };
-      const canRetry = !current.ok && attemptIndex < attempts.length - 1;
-      attemptIndex += 1;
-      if (!canRetry) return current;
-      const error = new Error('retry');
-      error.retryable = true;
-      error.result = current;
-      throw error;
-    }, {
-      maxAttempts: attempts.length,
-      baseDelayMs: 250,
-      maxDelayMs: 750,
-      shouldRetry: (error) => error?.retryable === true,
-    });
-  } catch (error) {
-    lastResult = error?.result || createResult(false, { stderr: String(error?.message || error) });
-  }
-
-  if (lastResult.ok) {
-    breaker.reset();
-    return lastResult;
-  }
-
-  breaker.recordFailure(entry.halfOpen);
-  return {
-    ...lastResult,
-    retried: attempts.length > 1,
-    fellBack: opts.fallbackToClaude !== false,
-  };
+export function execute(opts = {}) {
+  return executeWithCircuitBroker({
+    // Account-broker still stores this compatibility bucket as "gemini";
+    // execution itself is routed to agy above.
+    provider: "gemini",
+    runFn: runGemini,
+    preflightFn: (o) => runPreflight({ mcpServers: o.mcpServers }),
+    buildAttemptsFn: buildAttempts,
+    opts,
+  });
 }

package/hub/hitl.mjs

@@ -1,143 +1,202 @@
-// hub/hitl.mjs — Human-in-the-Loop 매니저
-// 사용자 입력 요청/응답, 타임아웃 자동 처리
-
-/**
- * HITL 매니저 생성
- * @param {object} store — createStore() 반환 객체
- * @param {object} router — createRouter() 반환 객체
- */
-export function createHitlManager(store, router = null) {
-  function forwardHumanResponse({ requesterAgent, requestId, action, content, submittedBy, correlationId, traceId, priority }) {
-    if (!router?.handlePublish) {
-      throw new Error('router.handlePublish is required for HITL forwarding');
-    }
-    return router.handlePublish({
-      from: 'hub:hitl',
-      to: requesterAgent,
-      topic: 'human.response',
-      priority,
-      ttl_ms: 300000,
-      payload: { request_id: requestId, action, content, submitted_by: submittedBy },
-      correlation_id: correlationId,
-      trace_id: traceId,
-      message_type: 'human_response',
-    });
-  }
-
-  return {
-    /**
-     * 사용자에게 입력 요청 생성
-     * 터미널에 알림 출력 후 pending 상태로 저장
-     */
-    requestHumanInput({
-      requester_agent, kind, prompt, requested_schema = {},
-      deadline_ms, default_action, channel_preference = 'terminal',
-      correlation_id, trace_id,
-    }) {
-      const result = store.insertHumanRequest({
-        requester_agent, kind, prompt, requested_schema,
-        deadline_ms, default_action,
-        correlation_id, trace_id,
-      });
-
-      // 터미널 알림 (stderr — stdout은 MCP 용)
-      const kindLabel = { captcha: 'CAPTCHA', approval: '승인', credential: '자격증명', choice: '선택', text: '텍스트' };
-      process.stderr.write(
-        `\n[tfx-hub] 사용자 입력 요청 (${kindLabel[kind] || kind})\n` +
-        `  요청자: ${requester_agent}\n` +
-        `  내용: ${prompt}\n` +
-        `  ID: ${result.request_id}\n` +
-        `  제한: ${Math.round(deadline_ms / 1000)}초\n\n`,
-      );
-
-      return { ok: true, data: result };
-    },
-
-    /**
-     * 사용자 입력 응답 제출
-     * 유효성 검증 → 상태 업데이트 → 요청자에게 응답 메시지 전달
-     */
-    submitHumanInput({ request_id, action, content = null, submitted_by = 'human' }) {
-      // 요청 조회
-      const hr = store.getHumanRequest(request_id);
-      if (!hr) {
-        return { ok: false, error: { code: 'NOT_FOUND', message: `요청 없음: ${request_id}` } };
-      }
-      if (hr.state !== 'pending') {
-        return { ok: false, error: { code: 'ALREADY_HANDLED', message: `이미 처리됨: ${hr.state}` } };
-      }
-
-      // 상태 매핑
-      const stateMap = { accept: 'accepted', decline: 'declined', cancel: 'cancelled' };
-      const newState = stateMap[action];
-      if (!newState) {
-        return { ok: false, error: { code: 'INVALID_ACTION', message: `잘못된 action: ${action}` } };
-      }
-
-      // DB 업데이트
-      store.updateHumanRequest(request_id, newState, content);
-
-      // 요청자에게 응답 메시지 전달
-      let forwardedMessageId = null;
-      if (action === 'accept' || action === 'decline') {
-        const published = forwardHumanResponse({
-          requesterAgent: hr.requester_agent,
-          requestId: request_id,
-          action,
-          content,
-          submittedBy: submitted_by,
-          correlationId: hr.correlation_id,
-          traceId: hr.trace_id,
-          priority: 7,
-        });
-        forwardedMessageId = published.data?.message_id || null;
-      }
-
-      return {
-        ok: true,
-        data: { request_id, new_state: newState, forwarded_message_id: forwardedMessageId },
-      };
-    },
-
-    /**
-     * 만료된 요청 자동 처리
-     * deadline 초과 시 default_action 적용
-     */
-    checkTimeouts() {
-      const pending = store.getPendingHumanRequests();
-      const now = Date.now();
-      const expired = pending.filter(hr => hr.deadline_ms <= now);
-      if (!expired.length) return 0;
-
-      const expireRequests = () => {
-        for (const hr of expired) {
-          store.updateHumanRequest(hr.request_id, 'timed_out', null);
-          if (hr.default_action === 'timeout_continue') {
-            forwardHumanResponse({
-              requesterAgent: hr.requester_agent,
-              requestId: hr.request_id,
-              action: 'timeout_continue',
-              content: null,
-              submittedBy: 'system',
-              correlationId: hr.correlation_id,
-              traceId: hr.trace_id,
-              priority: 5,
-            });
-          }
-        }
-        return expired.length;
-      };
-
-      const processExpired = store.db?.transaction
-        ? store.db.transaction(expireRequests)
-        : expireRequests;
-
-      return processExpired();
-    },
-
-    /** 대기 중인 요청 목록 */
-    getPendingRequests() {
-      return store.getPendingHumanRequests();
-    },
-  };
-}
+// hub/hitl.mjs — Human-in-the-Loop 매니저
+// 사용자 입력 요청/응답, 타임아웃 자동 처리
+
+/**
+ * HITL 매니저 생성
+ * @param {object} store — createStore() 반환 객체
+ * @param {object} router — createRouter() 반환 객체
+ */
+export function createHitlManager(store, router = null) {
+  function forwardHumanResponse({
+    requesterAgent,
+    requestId,
+    action,
+    content,
+    submittedBy,
+    correlationId,
+    traceId,
+    priority,
+  }) {
+    if (!router?.handlePublish) {
+      throw new Error("router.handlePublish is required for HITL forwarding");
+    }
+    return router.handlePublish({
+      from: "hub:hitl",
+      to: requesterAgent,
+      topic: "human.response",
+      priority,
+      ttl_ms: 300000,
+      payload: {
+        request_id: requestId,
+        action,
+        content,
+        submitted_by: submittedBy,
+      },
+      correlation_id: correlationId,
+      trace_id: traceId,
+      message_type: "human_response",
+    });
+  }
+
+  return {
+    /**
+     * 사용자에게 입력 요청 생성
+     * 터미널에 알림 출력 후 pending 상태로 저장
+     */
+    requestHumanInput({
+      requester_agent,
+      kind,
+      prompt,
+      requested_schema = {},
+      deadline_ms,
+      default_action,
+      channel_preference = "terminal",
+      correlation_id,
+      trace_id,
+    }) {
+      const result = store.insertHumanRequest({
+        requester_agent,
+        kind,
+        prompt,
+        requested_schema,
+        deadline_ms,
+        default_action,
+        correlation_id,
+        trace_id,
+      });
+
+      // 터미널 알림 (stderr — stdout은 MCP 용)
+      const kindLabel = {
+        captcha: "CAPTCHA",
+        approval: "승인",
+        credential: "자격증명",
+        choice: "선택",
+        text: "텍스트",
+      };
+      process.stderr.write(
+        `\n[tfx-hub] 사용자 입력 요청 (${kindLabel[kind] || kind})\n` +
+          `  요청자: ${requester_agent}\n` +
+          `  내용: ${prompt}\n` +
+          `  ID: ${result.request_id}\n` +
+          `  제한: ${Math.round(deadline_ms / 1000)}초\n\n`,
+      );
+
+      return { ok: true, data: result };
+    },
+
+    /**
+     * 사용자 입력 응답 제출
+     * 유효성 검증 → 상태 업데이트 → 요청자에게 응답 메시지 전달
+     */
+    submitHumanInput({
+      request_id,
+      action,
+      content = null,
+      submitted_by = "human",
+    }) {
+      // 요청 조회
+      const hr = store.getHumanRequest(request_id);
+      if (!hr) {
+        return {
+          ok: false,
+          error: { code: "NOT_FOUND", message: `요청 없음: ${request_id}` },
+        };
+      }
+      if (hr.state !== "pending") {
+        return {
+          ok: false,
+          error: {
+            code: "ALREADY_HANDLED",
+            message: `이미 처리됨: ${hr.state}`,
+          },
+        };
+      }
+
+      // 상태 매핑
+      const stateMap = {
+        accept: "accepted",
+        decline: "declined",
+        cancel: "cancelled",
+      };
+      const newState = stateMap[action];
+      if (!newState) {
+        return {
+          ok: false,
+          error: {
+            code: "INVALID_ACTION",
+            message: `잘못된 action: ${action}`,
+          },
+        };
+      }
+
+      // DB 업데이트
+      store.updateHumanRequest(request_id, newState, content);
+
+      // 요청자에게 응답 메시지 전달
+      let forwardedMessageId = null;
+      if (action === "accept" || action === "decline") {
+        const published = forwardHumanResponse({
+          requesterAgent: hr.requester_agent,
+          requestId: request_id,
+          action,
+          content,
+          submittedBy: submitted_by,
+          correlationId: hr.correlation_id,
+          traceId: hr.trace_id,
+          priority: 7,
+        });
+        forwardedMessageId = published.data?.message_id || null;
+      }
+
+      return {
+        ok: true,
+        data: {
+          request_id,
+          new_state: newState,
+          forwarded_message_id: forwardedMessageId,
+        },
+      };
+    },
+
+    /**
+     * 만료된 요청 자동 처리
+     * deadline 초과 시 default_action 적용
+     */
+    checkTimeouts() {
+      const pending = store.getPendingHumanRequests();
+      const now = Date.now();
+      const expired = pending.filter((hr) => hr.deadline_ms <= now);
+      if (!expired.length) return 0;
+
+      const expireRequests = () => {
+        for (const hr of expired) {
+          store.updateHumanRequest(hr.request_id, "timed_out", null);
+          if (hr.default_action === "timeout_continue") {
+            forwardHumanResponse({
+              requesterAgent: hr.requester_agent,
+              requestId: hr.request_id,
+              action: "timeout_continue",
+              content: null,
+              submittedBy: "system",
+              correlationId: hr.correlation_id,
+              traceId: hr.trace_id,
+              priority: 5,
+            });
+          }
+        }
+        return expired.length;
+      };
+
+      const processExpired = store.db?.transaction
+        ? store.db.transaction(expireRequests)
+        : expireRequests;
+
+      return processExpired();
+    },
+
+    /** 대기 중인 요청 목록 */
+    getPendingRequests() {
+      return store.getPendingHumanRequests();
+    },
+  };
+}