triflux 10.3.4 → 10.7.0

package/hub/workers/factory.mjs

@@ -1,19 +1,19 @@
 // hub/workers/factory.mjs — Worker 생성 팩토리
 
-import { GeminiWorker } from './gemini-worker.mjs';
-import { ClaudeWorker } from './claude-worker.mjs';
-import { CodexMcpWorker } from './codex-mcp.mjs';
-import { DelegatorMcpWorker } from './delegator-mcp.mjs';
+import { ClaudeWorker } from "./claude-worker.mjs";
+import { CodexMcpWorker } from "./codex-mcp.mjs";
+import { DelegatorMcpWorker } from "./delegator-mcp.mjs";
+import { GeminiWorker } from "./gemini-worker.mjs";
 
 export function createWorker(type, opts = {}) {
   switch (type) {
-    case 'gemini':
+    case "gemini":
       return new GeminiWorker(opts);
-    case 'claude':
+    case "claude":
       return new ClaudeWorker(opts);
-    case 'codex':
+    case "codex":
       return new CodexMcpWorker(opts);
-    case 'delegator':
+    case "delegator":
       return new DelegatorMcpWorker(opts);
     default:
       throw new Error(`Unknown worker type: ${type}`);

package/hub/workers/gemini-worker.mjs

@@ -1,20 +1,18 @@
 // hub/workers/gemini-worker.mjs — Gemini headless subprocess 래퍼
 // ADR-006: --output-format stream-json 기반 단발 실행 워커.
 
-import { spawn } from 'node:child_process';
-import { isAbsolute } from 'node:path';
-import readline from 'node:readline';
+import { spawn } from "node:child_process";
+import { isAbsolute } from "node:path";
+import readline from "node:readline";
 
-import { extractText, terminateChild, withRetry } from './worker-utils.mjs';
+import { extractText, terminateChild, withRetry } from "./worker-utils.mjs";
 
 const DEFAULT_TIMEOUT_MS = 15 * 60 * 1000;
 const DEFAULT_KILL_GRACE_MS = 1000;
 
 function toStringList(value) {
   if (!Array.isArray(value)) return [];
-  return value
-    .map((item) => String(item ?? '').trim())
-    .filter(Boolean);
+  return value.map((item) => String(item ?? "").trim()).filter(Boolean);
 }
 
 function safeJsonParse(line) {
@@ -36,25 +34,25 @@ function buildGeminiArgs(options) {
   const args = [];
 
   if (options.model) {
-    args.push('--model', options.model);
+    args.push("--model", options.model);
   }
 
   if (options.approvalMode) {
-    args.push('--approval-mode', options.approvalMode);
+    args.push("--approval-mode", options.approvalMode);
   } else if (options.yolo !== false) {
-    args.push('--yolo');
+    args.push("--yolo");
   }
 
   const allowedMcpServers = toStringList(options.allowedMcpServerNames);
   if (allowedMcpServers.length) {
-    args.push('--allowed-mcp-server-names', ...allowedMcpServers);
+    args.push("--allowed-mcp-server-names", ...allowedMcpServers);
   }
 
   const extraArgs = toStringList(options.extraArgs);
   if (extraArgs.length) args.push(...extraArgs);
 
-  args.push('--prompt', options.promptArgument ?? '');
-  args.push('--output-format', 'stream-json');
+  args.push("--prompt", options.promptArgument ?? "");
+  args.push("--output-format", "stream-json");
 
   return args;
 }
@@ -66,49 +64,59 @@ function createWorkerError(message, details = {}) {
 }
 
 function normalizeRetryOptions(retryOptions) {
-  if (!retryOptions || typeof retryOptions !== 'object') {
+  if (!retryOptions || typeof retryOptions !== "object") {
     return Object.freeze({});
   }
   return Object.freeze({ ...retryOptions });
 }
 
 function isGeminiRetryable(error) {
-  return error?.code === 'WORKER_EXIT'
-    && error?.result?.exitCode !== 0
-    && error?.result?.exitCode !== 2;
+  return (
+    error?.code === "WORKER_EXIT" &&
+    error?.result?.exitCode !== 0 &&
+    error?.result?.exitCode !== 2
+  );
 }
 
 function detectGeminiCategory(error) {
-  const combined = `${error?.message || ''}\n${error?.stderr || ''}`.toLowerCase();
-
-  if (/(unauthorized|forbidden|auth|login|token|credential|apikey|api key)/.test(combined)) {
-    return 'auth';
+  const combined =
+    `${error?.message || ""}\n${error?.stderr || ""}`.toLowerCase();
+
+  if (
+    /(unauthorized|forbidden|auth|login|token|credential|apikey|api key)/.test(
+      combined,
+    )
+  ) {
+    return "auth";
   }
-  if (error?.result?.exitCode === 2 || /expected stream-json|unknown option|invalid option|config/.test(combined)) {
-    return 'config';
+  if (
+    error?.result?.exitCode === 2 ||
+    /expected stream-json|unknown option|invalid option|config/.test(combined)
+  ) {
+    return "config";
   }
-  if (error?.code === 'WORKER_EVENT_ERROR') {
-    return 'input';
+  if (error?.code === "WORKER_EVENT_ERROR") {
+    return "input";
   }
 
-  return 'transient';
+  return "transient";
 }
 
 function buildGeminiErrorInfo(error, attempts) {
   const category = detectGeminiCategory(error);
   const retryable = isGeminiRetryable(error);
-  let recovery = 'Retry the Gemini worker after correcting the reported issue.';
-
-  if (category === 'auth') {
-    recovery = 'Refresh the Gemini authentication state and retry.';
-  } else if (category === 'config') {
-    recovery = 'Check the Gemini CLI flags and worker configuration.';
-  } else if (category === 'input') {
-    recovery = 'Check the Gemini request payload and streamed event format.';
+  let recovery = "Retry the Gemini worker after correcting the reported issue.";
+
+  if (category === "auth") {
+    recovery = "Refresh the Gemini authentication state and retry.";
+  } else if (category === "config") {
+    recovery = "Check the Gemini CLI flags and worker configuration.";
+  } else if (category === "input") {
+    recovery = "Check the Gemini request payload and streamed event format.";
   }
 
   return Object.freeze({
-    code: error?.code || 'GEMINI_EXECUTION_ERROR',
+    code: error?.code || "GEMINI_EXECUTION_ERROR",
     retryable,
     attempts,
     category,
@@ -120,10 +128,10 @@ function buildGeminiErrorInfo(error, attempts) {
  * Gemini stream-json 래퍼
  */
 export class GeminiWorker {
-  type = 'gemini';
+  type = "gemini";
 
   constructor(options = {}) {
-    this.command = options.command || 'gemini';
+    this.command = options.command || "gemini";
     this.commandArgs = toStringList(options.commandArgs || options.args);
     this.cwd = options.cwd || process.cwd();
     this.env = { ...process.env, ...(options.env || {}) };
@@ -132,19 +140,26 @@ export class GeminiWorker {
     this.yolo = options.yolo !== false;
     this.allowedMcpServerNames = toStringList(options.allowedMcpServerNames);
     this.extraArgs = toStringList(options.extraArgs);
-    this.timeoutMs = Number(options.timeoutMs) > 0 ? Number(options.timeoutMs) : DEFAULT_TIMEOUT_MS;
-    this.killGraceMs = Number(options.killGraceMs) > 0 ? Number(options.killGraceMs) : DEFAULT_KILL_GRACE_MS;
+    this.timeoutMs =
+      Number(options.timeoutMs) > 0
+        ? Number(options.timeoutMs)
+        : DEFAULT_TIMEOUT_MS;
+    this.killGraceMs =
+      Number(options.killGraceMs) > 0
+        ? Number(options.killGraceMs)
+        : DEFAULT_KILL_GRACE_MS;
     this.retryOptions = normalizeRetryOptions(options.retryOptions);
-    this.onEvent = typeof options.onEvent === 'function' ? options.onEvent : null;
+    this.onEvent =
+      typeof options.onEvent === "function" ? options.onEvent : null;
 
-    this.state = 'idle';
+    this.state = "idle";
     this.child = null;
     this.lastRun = null;
   }
 
   getStatus() {
     return {
-      type: 'gemini',
+      type: "gemini",
       state: this.state,
       pid: this.child?.pid || null,
       last_run_at_ms: this.lastRun?.finishedAtMs || null,
@@ -153,42 +168,47 @@ export class GeminiWorker {
   }
 
   async start() {
-    if (this.state === 'stopped') {
-      this.state = 'idle';
+    if (this.state === "stopped") {
+      this.state = "idle";
     }
     return this.getStatus();
   }
 
   async stop() {
     if (!this.child) {
-      this.state = 'stopped';
+      this.state = "stopped";
       return this.getStatus();
     }
     const child = this.child;
     terminateChild(child, this.killGraceMs);
     await new Promise((resolve) => {
-      child.once('close', resolve);
+      child.once("close", resolve);
       setTimeout(resolve, this.killGraceMs + 50).unref?.();
     });
     this.child = null;
-    this.state = 'stopped';
+    this.state = "stopped";
     return this.getStatus();
   }
 
   async restart() {
     await this.stop();
-    this.state = 'idle';
+    this.state = "idle";
     return this.getStatus();
   }
 
   async run(prompt, options = {}) {
     if (this.child) {
-      throw createWorkerError('GeminiWorker is already running', { code: 'WORKER_BUSY' });
+      throw createWorkerError("GeminiWorker is already running", {
+        code: "WORKER_BUSY",
+      });
     }
 
     await this.start();
 
-    const timeoutMs = Number(options.timeoutMs) > 0 ? Number(options.timeoutMs) : this.timeoutMs;
+    const timeoutMs =
+      Number(options.timeoutMs) > 0
+        ? Number(options.timeoutMs)
+        : this.timeoutMs;
     const startedAtMs = Date.now();
     const args = [
       ...this.commandArgs,
@@ -196,22 +216,23 @@ export class GeminiWorker {
         model: options.model || this.model,
         approvalMode: options.approvalMode || this.approvalMode,
         yolo: options.yolo ?? this.yolo,
-        allowedMcpServerNames: options.allowedMcpServerNames || this.allowedMcpServerNames,
+        allowedMcpServerNames:
+          options.allowedMcpServerNames || this.allowedMcpServerNames,
         extraArgs: options.extraArgs || this.extraArgs,
-        promptArgument: options.promptArgument ?? '',
+        promptArgument: options.promptArgument ?? "",
       }),
     ];
 
     const child = spawn(this.command, args, {
       cwd: options.cwd || this.cwd,
       env: { ...this.env, ...(options.env || {}) },
-      stdio: ['pipe', 'pipe', 'pipe'],
+      stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true,
-      shell: process.platform === 'win32' && !isAbsolute(this.command),
+      shell: process.platform === "win32" && !isAbsolute(this.command),
     });
 
     this.child = child;
-    this.state = 'running';
+    this.state = "running";
 
     const events = [];
     const stdoutLines = [];
@@ -230,7 +251,7 @@ export class GeminiWorker {
       crlfDelay: Infinity,
     });
 
-    stdoutReader.on('line', (line) => {
+    stdoutReader.on("line", (line) => {
       if (!line) return;
       const event = safeJsonParse(line);
       if (!event) {
@@ -239,20 +260,22 @@ export class GeminiWorker {
       }
 
       events.push(event);
-      if (event.type === 'error') lastErrorEvent = event;
+      if (event.type === "error") lastErrorEvent = event;
       if (this.onEvent) {
-        try { this.onEvent(event); } catch {}
+        try {
+          this.onEvent(event);
+        } catch {}
       }
     });
 
-    stderrReader.on('line', (line) => {
+    stderrReader.on("line", (line) => {
       if (!line) return;
       stderrLines.push(line);
     });
 
     const closePromise = new Promise((resolve, reject) => {
-      child.once('error', reject);
-      child.once('close', (code, signal) => {
+      child.once("error", reject);
+      child.once("close", (code, signal) => {
         exitCode = code;
         exitSignal = signal;
         resolve();
@@ -265,8 +288,8 @@ export class GeminiWorker {
     }, timeoutMs);
     timeout.unref?.();
 
-    child.stdin.on('error', () => {});
-    child.stdin.end(String(prompt ?? ''));
+    child.stdin.on("error", () => {});
+    child.stdin.end(String(prompt ?? ""));
 
     try {
       await closePromise;
@@ -277,32 +300,37 @@ export class GeminiWorker {
       if (this.child === child) {
         this.child = null;
       }
-      this.state = 'idle';
+      this.state = "idle";
     }
 
-    const resultEvent = findLastEvent(events, (event) => event?.type === 'result');
+    const resultEvent = findLastEvent(
+      events,
+      (event) => event?.type === "result",
+    );
     const response = [
       extractText(resultEvent),
       ...events
-        .filter((event) => event?.type === 'message' || event?.type === 'assistant')
+        .filter(
+          (event) => event?.type === "message" || event?.type === "assistant",
+        )
         .map((event) => extractText(event))
         .filter(Boolean),
       ...stdoutLines,
     ]
       .filter(Boolean)
-      .join('\n')
+      .join("\n")
       .trim();
 
     const result = {
-      type: 'gemini',
+      type: "gemini",
       command: this.command,
       args,
       response,
       events,
       resultEvent,
       usage: resultEvent?.usage || null,
-      stdout: stdoutLines.join('\n').trim(),
-      stderr: stderrLines.join('\n').trim(),
+      stdout: stdoutLines.join("\n").trim(),
+      stderr: stderrLines.join("\n").trim(),
       exitCode,
       exitSignal,
       timedOut,
@@ -314,7 +342,7 @@ export class GeminiWorker {
 
     if (timedOut) {
       throw createWorkerError(`Gemini worker timed out after ${timeoutMs}ms`, {
-        code: 'ETIMEDOUT',
+        code: "ETIMEDOUT",
         result,
         stderr: result.stderr,
       });
@@ -322,15 +350,15 @@ export class GeminiWorker {
 
     if (exitCode !== 0) {
       throw createWorkerError(`Gemini worker exited with code ${exitCode}`, {
-        code: 'WORKER_EXIT',
+        code: "WORKER_EXIT",
         result,
         stderr: result.stderr,
       });
     }
 
     if (lastErrorEvent) {
-      throw createWorkerError('Gemini worker emitted an error event', {
-        code: 'WORKER_EVENT_ERROR',
+      throw createWorkerError("Gemini worker emitted an error event", {
+        code: "WORKER_EVENT_ERROR",
         result,
         stderr: result.stderr,
       });
@@ -340,20 +368,23 @@ export class GeminiWorker {
   }
 
   isReady() {
-    return this.state !== 'stopped';
+    return this.state !== "stopped";
   }
 
   async execute(prompt, options = {}) {
     let attempts = 0;
 
     try {
-      const result = await withRetry(async () => {
-        attempts += 1;
-        return this.run(prompt, options);
-      }, {
-        ...this.retryOptions,
-        shouldRetry: (error) => isGeminiRetryable(error),
-      });
+      const result = await withRetry(
+        async () => {
+          attempts += 1;
+          return this.run(prompt, options);
+        },
+        {
+          ...this.retryOptions,
+          shouldRetry: (error) => isGeminiRetryable(error),
+        },
+      );
 
       return {
         output: result.response,
@@ -363,8 +394,8 @@ export class GeminiWorker {
       };
     } catch (error) {
       return {
-        output: error.stderr || error.message || 'Gemini worker failed',
-        exitCode: error.code === 'ETIMEDOUT' ? 124 : 1,
+        output: error.stderr || error.message || "Gemini worker failed",
+        exitCode: error.code === "ETIMEDOUT" ? 124 : 1,
         sessionKey: options.sessionKey || null,
         error: buildGeminiErrorInfo(error, attempts || 1),
         raw: error.result || null,

package/hub/workers/interface.mjs

@@ -49,4 +49,9 @@
  * @property {string} type - 'codex' | 'gemini' | 'claude' | 'delegator'
  */
 
-export const WORKER_TYPES = Object.freeze(['codex', 'gemini', 'claude', 'delegator']);
+export const WORKER_TYPES = Object.freeze([
+  "codex",
+  "gemini",
+  "claude",
+  "delegator",
+]);

package/hub/workers/worker-utils.mjs

@@ -6,9 +6,7 @@ export const DEFAULT_KILL_GRACE_MS = 1000;
 
 export function toStringList(value) {
   if (!Array.isArray(value)) return [];
-  return value
-    .map((item) => String(item ?? '').trim())
-    .filter(Boolean);
+  return value.map((item) => String(item ?? "").trim()).filter(Boolean);
 }
 
 export function safeJsonParse(line) {
@@ -51,8 +49,9 @@ export async function withRetry(fn, opts = {}) {
         throw error;
       }
 
-      const delay = Math.min(baseDelayMs * 2 ** (attempt - 1), maxDelayMs)
-        * (0.5 + Math.random() * 0.5);
+      const delay =
+        Math.min(baseDelayMs * 2 ** (attempt - 1), maxDelayMs) *
+        (0.5 + Math.random() * 0.5);
       await sleep(delay);
     }
   }
@@ -63,7 +62,7 @@ export async function withRetry(fn, opts = {}) {
 export function appendTextFragments(value, parts) {
   if (value == null) return;
 
-  if (typeof value === 'string') {
+  if (typeof value === "string") {
     const trimmed = value.trim();
     if (trimmed) parts.push(trimmed);
     return;
@@ -74,11 +73,13 @@ export function appendTextFragments(value, parts) {
     return;
   }
 
-  if (typeof value !== 'object') return;
+  if (typeof value !== "object") return;
 
-  if (typeof value.text === 'string') appendTextFragments(value.text, parts);
-  if (typeof value.response === 'string') appendTextFragments(value.response, parts);
-  if (typeof value.result === 'string') appendTextFragments(value.result, parts);
+  if (typeof value.text === "string") appendTextFragments(value.text, parts);
+  if (typeof value.response === "string")
+    appendTextFragments(value.response, parts);
+  if (typeof value.result === "string")
+    appendTextFragments(value.result, parts);
   if (value.content != null) appendTextFragments(value.content, parts);
   if (value.message != null) appendTextFragments(value.message, parts);
 }
@@ -86,18 +87,24 @@ export function appendTextFragments(value, parts) {
 export function extractText(value) {
   const parts = [];
   appendTextFragments(value, parts);
-  return parts.join('\n').trim();
+  return parts.join("\n").trim();
 }
 
 export function terminateChild(child, killGraceMs) {
   if (!child || child.exitCode !== null || child.killed) return;
 
-  try { child.stdin.end(); } catch {}
-  try { child.kill(); } catch {}
+  try {
+    child.stdin.end();
+  } catch {}
+  try {
+    child.kill();
+  } catch {}
 
   const timer = setTimeout(() => {
     if (child.exitCode === null) {
-      try { child.kill('SIGKILL'); } catch {}
+      try {
+        child.kill("SIGKILL");
+      } catch {}
     }
   }, killGraceMs);
   timer.unref?.();

package/hud/colors.mjs

@@ -12,15 +12,33 @@ export const CLAUDE_ORANGE = "\x1b[38;2;232;112;64m"; // #E87040 (Claude 공식
 export const CODEX_WHITE = "\x1b[97m"; // bright white (SGR 37은 Windows Terminal에서 연회색 매핑)
 export const GEMINI_BLUE = "\x1b[38;5;39m";
 
-export function green(t) { return `${GREEN}${t}${RESET}`; }
-export function yellow(t) { return `${YELLOW}${t}${RESET}`; }
-export function red(t) { return `${RED}${t}${RESET}`; }
-export function cyan(t) { return `${CYAN}${t}${RESET}`; }
-export function dim(t) { return `${DIM}${t}${RESET}`; }
-export function bold(t) { return `${BOLD}${t}${RESET}`; }
-export function claudeOrange(t) { return `${CLAUDE_ORANGE}${t}${RESET}`; }
-export function codexWhite(t) { return `${CODEX_WHITE}${t}${RESET}`; }
-export function geminiBlue(t) { return `${GEMINI_BLUE}${t}${RESET}`; }
+export function green(t) {
+  return `${GREEN}${t}${RESET}`;
+}
+export function yellow(t) {
+  return `${YELLOW}${t}${RESET}`;
+}
+export function red(t) {
+  return `${RED}${t}${RESET}`;
+}
+export function cyan(t) {
+  return `${CYAN}${t}${RESET}`;
+}
+export function dim(t) {
+  return `${DIM}${t}${RESET}`;
+}
+export function bold(t) {
+  return `${BOLD}${t}${RESET}`;
+}
+export function claudeOrange(t) {
+  return `${CLAUDE_ORANGE}${t}${RESET}`;
+}
+export function codexWhite(t) {
+  return `${CODEX_WHITE}${t}${RESET}`;
+}
+export function geminiBlue(t) {
+  return `${GEMINI_BLUE}${t}${RESET}`;
+}
 
 export function colorByPercent(value, text) {
   if (value >= 85) return red(text);