triflux 10.3.4 → 10.7.0

package/hub/fullcycle.mjs

@@ -1,14 +1,21 @@
 // hub/fullcycle.mjs — tfx-fullcycle runtime artifact/state helpers
 
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { ensureTfxDirs, TFX_FULLCYCLE_DIR, TFX_PLANS_DIR } from './paths.mjs';
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { join, resolve } from "node:path";
+import { ensureTfxDirs, TFX_FULLCYCLE_DIR, TFX_PLANS_DIR } from "./paths.mjs";
 
 function safeResolve(baseDir, relativePath) {
   const base = resolve(baseDir);
   const target = resolve(join(baseDir, relativePath));
   if (!target.startsWith(base)) {
-    throw new Error('Invalid fullcycle path: path traversal detected');
+    throw new Error("Invalid fullcycle path: path traversal detected");
   }
   return target;
 }
@@ -17,9 +24,9 @@ function safeResolve(baseDir, relativePath) {
 export function createFullcycleRunId(now = new Date()) {
   return now
     .toISOString()
-    .replace(/[:.]/g, '-')
-    .replace('T', '_')
-    .replace('Z', 'Z');
+    .replace(/[:.]/g, "-")
+    .replace("T", "_")
+    .replace("Z", "Z");
 }
 
 export function getFullcycleRunDir(runId, baseDir = process.cwd()) {
@@ -33,32 +40,41 @@ export function ensureFullcycleRunDir(runId, baseDir = process.cwd()) {
   return dir;
 }
 
-export function saveFullcycleArtifact(runId, filename, content, baseDir = process.cwd()) {
-  if (!filename || typeof filename !== 'string') {
-    throw new Error('Artifact filename is required');
+export function saveFullcycleArtifact(
+  runId,
+  filename,
+  content,
+  baseDir = process.cwd(),
+) {
+  if (!filename || typeof filename !== "string") {
+    throw new Error("Artifact filename is required");
   }
 
   const dir = ensureFullcycleRunDir(runId, baseDir);
   const path = safeResolve(dir, filename);
-  writeFileSync(path, content, 'utf8');
+  writeFileSync(path, content, "utf8");
   return path;
 }
 
-export function readFullcycleArtifact(runId, filename, baseDir = process.cwd()) {
+export function readFullcycleArtifact(
+  runId,
+  filename,
+  baseDir = process.cwd(),
+) {
   const dir = getFullcycleRunDir(runId, baseDir);
   const path = safeResolve(dir, filename);
   if (!existsSync(path)) return null;
-  return readFileSync(path, 'utf8');
+  return readFileSync(path, "utf8");
 }
 
 export function writeFullcycleState(runId, state, baseDir = process.cwd()) {
-  const payload = typeof state === 'object' && state !== null ? state : {};
+  const payload = typeof state === "object" && state !== null ? state : {};
   const serialized = JSON.stringify(payload, null, 2);
-  return saveFullcycleArtifact(runId, 'state.json', serialized, baseDir);
+  return saveFullcycleArtifact(runId, "state.json", serialized, baseDir);
 }
 
 export function readFullcycleState(runId, baseDir = process.cwd()) {
-  const content = readFullcycleArtifact(runId, 'state.json', baseDir);
+  const content = readFullcycleArtifact(runId, "state.json", baseDir);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -87,7 +103,7 @@ export function shouldStopQaLoop(failureHistory = [], maxRepeats = 3) {
   if (!Array.isArray(failureHistory) || maxRepeats <= 1) return false;
 
   const normalized = failureHistory
-    .map((entry) => String(entry ?? '').trim())
+    .map((entry) => String(entry ?? "").trim())
     .filter(Boolean);
 
   if (normalized.length < maxRepeats) return false;

package/hub/gemini-adapter.mjs

@@ -1,41 +1,42 @@
 // hub/gemini-adapter.mjs — Gemini CLI 방어 계층
 // codex-adapter.mjs와 동일 패턴, cli-adapter-base 공통 인터페이스 사용
 
-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';
-
-const breaker = createCircuitBreaker();
+  shellQuote,
+} from "./cli-adapter-base.mjs";
+import { whichCommandAsync } from "./platform.mjs";
 
 // ── Gemini-specific 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');
+  const geminiPath = await whichCommandAsync("gemini");
   if (!geminiPath) {
     return {
       geminiPath: null,
-      warnings: ['Gemini CLI not found. Install Gemini and ensure `gemini` is available on PATH.'],
+      warnings: [
+        "Gemini CLI not found. Install Gemini and ensure `gemini` is available on PATH.",
+      ],
       excludeMcpServers: [],
       ok: false,
     };
@@ -45,7 +46,7 @@ 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)
@@ -57,26 +58,33 @@ async function runPreflight(opts = {}) {
 // ── Command building ────────────────────────────────────────────
 
 function buildGeminiCommand(prompt, resultFile, opts = {}) {
-  const parts = ['gemini'];
+  const parts = ["gemini"];
 
-  if (opts.model) parts.push('--model', shellQuote(opts.model));
-  parts.push('--yolo');
+  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 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(
+      "--allowed-mcp-server-names",
+      ...filtered.map((n) => shellQuote(n)),
+    );
   }
 
-  parts.push('--prompt', shellQuote(prompt));
-  parts.push('--output-format', 'text');
+  parts.push("--prompt", shellQuote(prompt));
+  parts.push("--output-format", "text");
 
   if (resultFile) {
-    return `${parts.join(' ')} > ${shellQuote(normalizePathForShell(resultFile))} 2>${shellQuote(normalizePathForShell(resultFile + '.err'))}`;
+    return `${parts.join(" ")} > ${shellQuote(normalizePathForShell(resultFile))} 2>${shellQuote(normalizePathForShell(resultFile + ".err"))}`;
   }
 
-  return parts.join(' ');
+  return parts.join(" ");
 }
 
 function buildAttempts(opts, preflight) {
@@ -84,20 +92,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,
@@ -107,74 +114,42 @@ export function buildExecArgs(opts = {}) {
 // ── Execution ───────────────────────────────────────────────────
 
 async function runGemini(prompt, workdir, preflight, attempt) {
-  const dir = join(tmpdir(), 'triflux-gemini-exec');
+  const dir = join(tmpdir(), "triflux-gemini-exec");
   mkdirSync(dir, { recursive: true });
-  const resultFile = join(dir, `gemini-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
+  const resultFile = join(
+    dir,
+    `gemini-${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 });
+  return runProcess(command, workdir, attempt.timeout, {
+    resultFile,
+    inferStallMode,
+  });
 }
 
 // ── 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({
+    provider: "gemini",
+    runFn: runGemini,
+    preflightFn: (o) => runPreflight({ mcpServers: o.mcpServers }),
+    buildAttemptsFn: buildAttempts,
+    opts,
+  });
 }

package/hub/hitl.mjs

@@ -7,20 +7,34 @@
  * @param {object} router — createRouter() 반환 객체
  */
 export function createHitlManager(store, router = null) {
-  function forwardHumanResponse({ requesterAgent, requestId, action, content, submittedBy, correlationId, traceId, priority }) {
+  function forwardHumanResponse({
+    requesterAgent,
+    requestId,
+    action,
+    content,
+    submittedBy,
+    correlationId,
+    traceId,
+    priority,
+  }) {
     if (!router?.handlePublish) {
-      throw new Error('router.handlePublish is required for HITL forwarding');
+      throw new Error("router.handlePublish is required for HITL forwarding");
     }
     return router.handlePublish({
-      from: 'hub:hitl',
+      from: "hub:hitl",
       to: requesterAgent,
-      topic: 'human.response',
+      topic: "human.response",
       priority,
       ttl_ms: 300000,
-      payload: { request_id: requestId, action, content, submitted_by: submittedBy },
+      payload: {
+        request_id: requestId,
+        action,
+        content,
+        submitted_by: submittedBy,
+      },
       correlation_id: correlationId,
       trace_id: traceId,
-      message_type: 'human_response',
+      message_type: "human_response",
     });
   }
 
@@ -30,24 +44,41 @@ export function createHitlManager(store, router = null) {
      * 터미널에 알림 출력 후 pending 상태로 저장
      */
     requestHumanInput({
-      requester_agent, kind, prompt, requested_schema = {},
-      deadline_ms, default_action, channel_preference = 'terminal',
-      correlation_id, trace_id,
+      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,
+        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: '텍스트' };
+      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`,
+          `  요청자: ${requester_agent}\n` +
+          `  내용: ${prompt}\n` +
+          `  ID: ${result.request_id}\n` +
+          `  제한: ${Math.round(deadline_ms / 1000)}초\n\n`,
       );
 
       return { ok: true, data: result };
@@ -57,21 +88,45 @@ export function createHitlManager(store, router = null) {
      * 사용자 입력 응답 제출
      * 유효성 검증 → 상태 업데이트 → 요청자에게 응답 메시지 전달
      */
-    submitHumanInput({ request_id, action, content = null, submitted_by = 'human' }) {
+    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}` } };
+        return {
+          ok: false,
+          error: { code: "NOT_FOUND", message: `요청 없음: ${request_id}` },
+        };
       }
-      if (hr.state !== 'pending') {
-        return { ok: false, error: { code: 'ALREADY_HANDLED', message: `이미 처리됨: ${hr.state}` } };
+      if (hr.state !== "pending") {
+        return {
+          ok: false,
+          error: {
+            code: "ALREADY_HANDLED",
+            message: `이미 처리됨: ${hr.state}`,
+          },
+        };
       }
 
       // 상태 매핑
-      const stateMap = { accept: 'accepted', decline: 'declined', cancel: 'cancelled' };
+      const stateMap = {
+        accept: "accepted",
+        decline: "declined",
+        cancel: "cancelled",
+      };
       const newState = stateMap[action];
       if (!newState) {
-        return { ok: false, error: { code: 'INVALID_ACTION', message: `잘못된 action: ${action}` } };
+        return {
+          ok: false,
+          error: {
+            code: "INVALID_ACTION",
+            message: `잘못된 action: ${action}`,
+          },
+        };
       }
 
       // DB 업데이트
@@ -79,7 +134,7 @@ export function createHitlManager(store, router = null) {
 
       // 요청자에게 응답 메시지 전달
       let forwardedMessageId = null;
-      if (action === 'accept' || action === 'decline') {
+      if (action === "accept" || action === "decline") {
         const published = forwardHumanResponse({
           requesterAgent: hr.requester_agent,
           requestId: request_id,
@@ -95,7 +150,11 @@ export function createHitlManager(store, router = null) {
 
       return {
         ok: true,
-        data: { request_id, new_state: newState, forwarded_message_id: forwardedMessageId },
+        data: {
+          request_id,
+          new_state: newState,
+          forwarded_message_id: forwardedMessageId,
+        },
       };
     },
 
@@ -106,19 +165,19 @@ export function createHitlManager(store, router = null) {
     checkTimeouts() {
       const pending = store.getPendingHumanRequests();
       const now = Date.now();
-      const expired = pending.filter(hr => hr.deadline_ms <= 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') {
+          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',
+              action: "timeout_continue",
               content: null,
-              submittedBy: 'system',
+              submittedBy: "system",
               correlationId: hr.correlation_id,
               traceId: hr.trace_id,
               priority: 5,