triflux 10.3.4 → 10.7.0

package/hub/codex-preflight.mjs

@@ -1,28 +1,30 @@
-import { readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { execSync } from 'node:child_process';
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 
-import { whichCommandAsync } from './platform.mjs';
+import { whichCommandAsync } from "./platform.mjs";
 
 const MIN_RECOMMENDED_MINOR = 118;
 let _cachedVersion = null;
 
 function escapeRegExp(value) {
-  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-function readConfigText(configPath = join(homedir(), '.codex', 'config.toml')) {
-  if (!existsSync(configPath)) return '';
+function readConfigText(configPath = join(homedir(), ".codex", "config.toml")) {
+  if (!existsSync(configPath)) return "";
   try {
-    return readFileSync(configPath, 'utf8');
+    return readFileSync(configPath, "utf8");
   } catch {
-    return '';
+    return "";
   }
 }
 
 function readTomlString(text, key) {
-  const match = String(text).match(new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"([^"]*)"\\s*$`, 'mu'));
+  const match = String(text).match(
+    new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"([^"]*)"\\s*$`, "mu"),
+  );
   return match?.[1] ?? null;
 }
 
@@ -30,13 +32,13 @@ function readSection(text, name) {
   const lines = String(text).split(/\r?\n/u);
   const header = `[${name}]`;
   const start = lines.findIndex((line) => line.trim() === header);
-  if (start < 0) return '';
+  if (start < 0) return "";
   const body = [];
   for (const line of lines.slice(start + 1)) {
     if (/^\s*\[[^\]]+\]\s*$/u.test(line)) break;
     body.push(line);
   }
-  return body.join('\n');
+  return body.join("\n");
 }
 
 /**
@@ -47,7 +49,10 @@ function readSection(text, name) {
 export function getCodexVersion() {
   if (_cachedVersion !== null) return _cachedVersion;
   try {
-    const out = execSync('codex --version', { encoding: 'utf8', timeout: 5000 }).trim();
+    const out = execSync("codex --version", {
+      encoding: "utf8",
+      timeout: 5000,
+    }).trim();
     // "codex 0.117.0" 또는 "0.117.0" 형식 대응
     const match = out.match(/(\d+)\.(\d+)\.(\d+)/);
     _cachedVersion = match ? parseInt(match[2], 10) : 0;
@@ -58,29 +63,34 @@ export function getCodexVersion() {
 }
 
 async function checkCodexInstalled() {
-  const codexPath = await whichCommandAsync('codex');
+  const codexPath = await whichCommandAsync("codex");
   if (codexPath) return { codexPath, ok: true, warnings: [] };
   return {
     codexPath: null,
     ok: false,
-    warnings: ['Codex CLI not found. Install Codex and ensure `codex` is available on PATH.'],
+    warnings: [
+      "Codex CLI not found. Install Codex and ensure `codex` is available on PATH.",
+    ],
   };
 }
 
 function checkCodexVersion() {
   const version = getCodexVersion();
-  const warnings = version >= MIN_RECOMMENDED_MINOR
-    ? []
-    : [`Codex CLI 0.${version}.x detected; 0.${MIN_RECOMMENDED_MINOR}.x or newer is recommended.`];
+  const warnings =
+    version >= MIN_RECOMMENDED_MINOR
+      ? []
+      : [
+          `Codex CLI 0.${version}.x detected; 0.${MIN_RECOMMENDED_MINOR}.x or newer is recommended.`,
+        ];
   return { version, warnings };
 }
 
 function checkApprovalMode(configText, opts = {}) {
-  const approvalMode = readTomlString(configText, 'approval_mode');
-  const sandbox = readTomlString(configText, 'sandbox');
-  const subcommand = opts.subcommand || 'exec';
+  const approvalMode = readTomlString(configText, "approval_mode");
+  const sandbox = readTomlString(configText, "sandbox");
+  const subcommand = opts.subcommand || "exec";
   return {
-    needsBypass: subcommand === 'exec' || approvalMode !== 'full-auto',
+    needsBypass: subcommand === "exec" || approvalMode !== "full-auto",
     approvalMode,
     sandbox,
   };
@@ -88,28 +98,41 @@ function checkApprovalMode(configText, opts = {}) {
 
 async function verifyServerHealth(name, configText) {
   const section = readSection(configText, `mcp_servers.${name}`);
-  if (!section) return { ok: false, warning: `MCP server '${name}' is not configured.` };
+  if (!section)
+    return { ok: false, warning: `MCP server '${name}' is not configured.` };
   if (/^\s*enabled\s*=\s*false\s*$/mu.test(section)) {
-    return { ok: false, warning: `MCP server '${name}' is disabled in config.toml.` };
+    return {
+      ok: false,
+      warning: `MCP server '${name}' is disabled in config.toml.`,
+    };
   }
 
-  const command = readTomlString(section, 'command');
+  const command = readTomlString(section, "command");
   if (command) {
     const resolved = await whichCommandAsync(command);
     return resolved
-      ? { ok: true, warning: '' }
-      : { ok: false, warning: `MCP server '${name}' command not found: ${command}` };
+      ? { ok: true, warning: "" }
+      : {
+          ok: false,
+          warning: `MCP server '${name}' command not found: ${command}`,
+        };
   }
 
-  const url = readTomlString(section, 'url');
-  if (!url || !/^https?:\/\//u.test(url)) return { ok: true, warning: '' };
+  const url = readTomlString(section, "url");
+  if (!url || !/^https?:\/\//u.test(url)) return { ok: true, warning: "" };
   try {
     const response = await fetch(url, { signal: AbortSignal.timeout(2000) });
     return response.status < 500
-      ? { ok: true, warning: '' }
-      : { ok: false, warning: `MCP server '${name}' returned HTTP ${response.status}.` };
+      ? { ok: true, warning: "" }
+      : {
+          ok: false,
+          warning: `MCP server '${name}' returned HTTP ${response.status}.`,
+        };
   } catch {
-    return { ok: false, warning: `MCP server '${name}' is unreachable at ${url}.` };
+    return {
+      ok: false,
+      warning: `MCP server '${name}' is unreachable at ${url}.`,
+    };
   }
 }
 
@@ -118,7 +141,7 @@ async function checkMcpHealth(mcpServers, configText) {
   const warnings = [];
 
   for (const name of Array.isArray(mcpServers) ? mcpServers : []) {
-    const server = String(name ?? '').trim();
+    const server = String(name ?? "").trim();
     if (!server) continue;
     const result = await verifyServerHealth(server, configText);
     if (!result.ok) excludeMcpServers.push(server);
@@ -147,10 +170,13 @@ export async function runPreflight(opts = {}) {
 
   const configText = readConfigText(opts.configPath);
   const approval = checkApprovalMode(configText, opts);
-  if (approval.approvalMode !== 'full-auto') {
-    warnings.push(`approval_mode is '${approval.approvalMode || 'unset'}'; bypass flag will be used.`);
+  if (approval.approvalMode !== "full-auto") {
+    warnings.push(
+      `approval_mode is '${approval.approvalMode || "unset"}'; bypass flag will be used.`,
+    );
   }
-  if (approval.sandbox) warnings.push(`sandbox mode from config.toml: ${approval.sandbox}`);
+  if (approval.sandbox)
+    warnings.push(`sandbox mode from config.toml: ${approval.sandbox}`);
 
   const mcp = await checkMcpHealth(opts.mcpServers, configText);
   warnings.push(...mcp.warnings);

package/hub/delegator/contracts.mjs

@@ -1,37 +1,33 @@
 export const DELEGATOR_MCP_SERVER_INFO = Object.freeze({
-  name: 'triflux-delegator',
-  version: '0.1.0',
+  name: "triflux-delegator",
+  version: "0.1.0",
 });
 
 export const DELEGATOR_TOOL_NAMES = Object.freeze({
-  delegate: 'delegate',
-  delegateReply: 'delegate-reply',
-  status: 'status',
+  delegate: "delegate",
+  delegateReply: "delegate-reply",
+  status: "status",
 });
 
 export const DELEGATOR_PIPE_ACTIONS = Object.freeze({
-  delegate: 'delegator_delegate',
-  delegateReply: 'delegator_reply',
-  status: 'delegator_status',
+  delegate: "delegator_delegate",
+  delegateReply: "delegator_reply",
+  status: "delegator_status",
 });
 
 export const DELEGATOR_JOB_STATUSES = Object.freeze([
-  'queued',
-  'running',
-  'waiting_reply',
-  'completed',
-  'failed',
+  "queued",
+  "running",
+  "waiting_reply",
+  "completed",
+  "failed",
 ]);
 
-export const DELEGATOR_MODES = Object.freeze([
-  'sync',
-  'async',
-]);
+export const DELEGATOR_MODES = Object.freeze(["sync", "async"]);
 
-export const DELEGATOR_PROVIDERS = Object.freeze([
-  'auto',
-  'codex',
-  'gemini',
-]);
+export const DELEGATOR_PROVIDERS = Object.freeze(["auto", "codex", "gemini"]);
 
-export const DELEGATOR_SCHEMA_URL = new URL('./schema/delegator-tools.schema.json', import.meta.url);
+export const DELEGATOR_SCHEMA_URL = new URL(
+  "./schema/delegator-tools.schema.json",
+  import.meta.url,
+);

package/hub/delegator/index.mjs

@@ -6,9 +6,9 @@ export {
   DELEGATOR_PROVIDERS,
   DELEGATOR_SCHEMA_URL,
   DELEGATOR_TOOL_NAMES,
-} from './contracts.mjs';
-export { DelegatorService } from './service.mjs';
+} from "./contracts.mjs";
+export { DelegatorService } from "./service.mjs";
 export {
   getDelegatorMcpToolDefinitions,
   loadDelegatorSchemaBundle,
-} from './tool-definitions.mjs';
+} from "./tool-definitions.mjs";

package/hub/delegator/service.mjs

@@ -1,11 +1,11 @@
-import { randomUUID } from 'node:crypto';
+import { randomUUID } from "node:crypto";
 
 import {
   DELEGATOR_JOB_STATUSES,
   DELEGATOR_MODES,
   DELEGATOR_PROVIDERS,
-} from './contracts.mjs';
-import { getDelegatorMcpToolDefinitions } from './tool-definitions.mjs';
+} from "./contracts.mjs";
+import { getDelegatorMcpToolDefinitions } from "./tool-definitions.mjs";
 
 function deepClone(value) {
   if (value == null) return value;
@@ -39,28 +39,28 @@ export class DelegatorService {
   createJobSnapshot(input = {}) {
     const timestamp = this.now().toISOString();
     const jobId = input.job_id || this.idFactory();
-    const mode = input.mode || 'sync';
-    const providerRequested = input.provider || 'auto';
+    const mode = input.mode || "sync";
+    const providerRequested = input.provider || "auto";
 
-    assertKnown(DELEGATOR_MODES, mode, 'mode');
-    assertKnown(DELEGATOR_PROVIDERS, providerRequested, 'provider');
+    assertKnown(DELEGATOR_MODES, mode, "mode");
+    assertKnown(DELEGATOR_PROVIDERS, providerRequested, "provider");
 
     return {
       ok: true,
       job_id: jobId,
-      status: 'queued',
+      status: "queued",
       mode,
       provider_requested: providerRequested,
       provider_resolved: null,
-      agent_type: input.agent_type || 'executor',
-      transport: 'resident-pending',
+      agent_type: input.agent_type || "executor",
+      transport: "resident-pending",
       created_at: timestamp,
       started_at: null,
       updated_at: timestamp,
       completed_at: null,
-      output: '',
-      stderr: '',
-      error: '',
+      output: "",
+      stderr: "",
+      error: "",
       thread_id: input.thread_id || null,
       session_key: input.session_key || null,
       conversation_open: false,
@@ -69,9 +69,9 @@ export class DelegatorService {
 
   recordJob(snapshot) {
     if (!snapshot?.job_id) {
-      throw new Error('job_id is required');
+      throw new Error("job_id is required");
     }
-    assertKnown(DELEGATOR_JOB_STATUSES, snapshot.status, 'status');
+    assertKnown(DELEGATOR_JOB_STATUSES, snapshot.status, "status");
     this.jobs.set(snapshot.job_id, deepClone(snapshot));
     return this.getStatusSnapshot(snapshot.job_id);
   }
@@ -86,19 +86,20 @@ export class DelegatorService {
   _normalizeInput(input = {}) {
     return {
       prompt: input.prompt,
-      provider: input.provider || 'auto',
-      mode: input.mode || 'sync',
-      agent_type: input.agent_type || input.agentType || 'executor',
+      provider: input.provider || "auto",
+      mode: input.mode || "sync",
+      agent_type: input.agent_type || input.agentType || "executor",
       cwd: input.cwd || null,
       timeout_ms: input.timeout_ms || input.timeoutMs || null,
       session_key: input.session_key || input.sessionKey || null,
       thread_id: input.thread_id || input.threadId || null,
       reset_session: input.reset_session ?? input.resetSession ?? false,
-      mcp_profile: input.mcp_profile || input.mcpProfile || 'auto',
+      mcp_profile: input.mcp_profile || input.mcpProfile || "auto",
       search_tool: input.search_tool || input.searchTool || null,
       context_file: input.context_file || input.contextFile || null,
       model: input.model || null,
-      developer_instructions: input.developer_instructions || input.developerInstructions || null,
+      developer_instructions:
+        input.developer_instructions || input.developerInstructions || null,
       compact_prompt: input.compact_prompt || input.compactPrompt || null,
     };
   }
@@ -131,18 +132,22 @@ export class DelegatorService {
     const ok = workerResult.ok !== false;
 
     snapshot.ok = ok;
-    snapshot.status = workerResult.status || (ok ? 'completed' : 'failed');
-    snapshot.provider_resolved = workerResult.providerResolved || workerResult.provider_resolved || null;
+    snapshot.status = workerResult.status || (ok ? "completed" : "failed");
+    snapshot.provider_resolved =
+      workerResult.providerResolved || workerResult.provider_resolved || null;
     snapshot.transport = workerResult.transport || snapshot.transport;
-    snapshot.output = workerResult.output || '';
-    snapshot.stderr = workerResult.stderr || '';
-    snapshot.error = workerResult.error || '';
-    snapshot.thread_id = workerResult.threadId || workerResult.thread_id || null;
-    snapshot.session_key = workerResult.sessionKey || workerResult.session_key || null;
-    snapshot.conversation_open = workerResult.conversationOpen ?? workerResult.conversation_open ?? false;
+    snapshot.output = workerResult.output || "";
+    snapshot.stderr = workerResult.stderr || "";
+    snapshot.error = workerResult.error || "";
+    snapshot.thread_id =
+      workerResult.threadId || workerResult.thread_id || null;
+    snapshot.session_key =
+      workerResult.sessionKey || workerResult.session_key || null;
+    snapshot.conversation_open =
+      workerResult.conversationOpen ?? workerResult.conversation_open ?? false;
     snapshot.started_at = snapshot.started_at || timestamp;
     snapshot.updated_at = timestamp;
-    if (snapshot.status === 'completed' || snapshot.status === 'failed') {
+    if (snapshot.status === "completed" || snapshot.status === "failed") {
       snapshot.completed_at = timestamp;
     }
 
@@ -155,7 +160,7 @@ export class DelegatorService {
     if (snapshot) {
       const timestamp = this.now().toISOString();
       snapshot.ok = false;
-      snapshot.status = 'failed';
+      snapshot.status = "failed";
       snapshot.error = error;
       snapshot.updated_at = timestamp;
       snapshot.completed_at = timestamp;
@@ -169,19 +174,19 @@ export class DelegatorService {
     const timestamp = this.now().toISOString();
     return {
       ok: false,
-      job_id: jobId || 'unknown',
-      status: 'failed',
-      mode: 'sync',
-      provider_requested: 'auto',
+      job_id: jobId || "unknown",
+      status: "failed",
+      mode: "sync",
+      provider_requested: "auto",
       provider_resolved: null,
-      agent_type: 'executor',
-      transport: 'resident-pending',
+      agent_type: "executor",
+      transport: "resident-pending",
       created_at: timestamp,
       started_at: null,
       updated_at: timestamp,
       completed_at: timestamp,
-      output: '',
-      stderr: '',
+      output: "",
+      stderr: "",
       error,
       thread_id: null,
       session_key: null,
@@ -194,15 +199,19 @@ export class DelegatorService {
   async delegate(input = {}) {
     const normalized = this._normalizeInput(input);
 
-    if (!normalized.prompt || typeof normalized.prompt !== 'string' || !normalized.prompt.trim()) {
-      return this._errorSnapshot(null, 'prompt is required');
+    if (
+      !normalized.prompt ||
+      typeof normalized.prompt !== "string" ||
+      !normalized.prompt.trim()
+    ) {
+      return this._errorSnapshot(null, "prompt is required");
     }
 
     const snapshot = this.createJobSnapshot(normalized);
     this.recordJob(snapshot);
 
     if (!this.worker) {
-      return this._failJob(snapshot.job_id, 'worker가 설정되지 않았습니다');
+      return this._failJob(snapshot.job_id, "worker가 설정되지 않았습니다");
     }
 
     const workerArgs = this._toWorkerArgs(normalized);
@@ -218,44 +227,53 @@ export class DelegatorService {
 
       return this._applyWorkerResult(snapshot.job_id, workerResult);
     } catch (err) {
-      return this._failJob(snapshot.job_id, err instanceof Error ? err.message : String(err));
+      return this._failJob(
+        snapshot.job_id,
+        err instanceof Error ? err.message : String(err),
+      );
     }
   }
 
   async reply(input = {}) {
     const jobId = input.job_id || input.jobId;
     if (!jobId) {
-      return this._errorSnapshot('unknown', 'job_id is required');
+      return this._errorSnapshot("unknown", "job_id is required");
     }
 
     const snapshot = this.jobs.get(jobId);
     if (!snapshot) {
-      return this._errorSnapshot(jobId, 'job not found');
+      return this._errorSnapshot(jobId, "job not found");
     }
 
     if (!snapshot.conversation_open) {
-      return this._failJob(jobId, 'conversation is not open');
+      return this._failJob(jobId, "conversation is not open");
     }
 
     if (!this.worker) {
-      return this._failJob(jobId, 'worker가 설정되지 않았습니다');
+      return this._failJob(jobId, "worker가 설정되지 않았습니다");
     }
 
     const workerJobId = this._workerJobMap.get(jobId);
     if (!workerJobId) {
-      return this._failJob(jobId, 'worker job 매핑을 찾을 수 없습니다');
+      return this._failJob(jobId, "worker job 매핑을 찾을 수 없습니다");
     }
 
     try {
-      const workerResult = await this.worker.reply({
-        job_id: workerJobId,
-        reply: input.reply,
-        done: input.done ?? false,
-      }, null);
+      const workerResult = await this.worker.reply(
+        {
+          job_id: workerJobId,
+          reply: input.reply,
+          done: input.done ?? false,
+        },
+        null,
+      );
 
       return this._applyWorkerResult(jobId, workerResult);
     } catch (err) {
-      return this._failJob(jobId, err instanceof Error ? err.message : String(err));
+      return this._failJob(
+        jobId,
+        err instanceof Error ? err.message : String(err),
+      );
     }
   }
 
@@ -267,20 +285,20 @@ export class DelegatorService {
       const timestamp = this.now().toISOString();
       return {
         ok: false,
-        job_id: resolvedId || 'unknown-job',
-        status: 'failed',
-        mode: 'async',
-        provider_requested: 'auto',
+        job_id: resolvedId || "unknown-job",
+        status: "failed",
+        mode: "async",
+        provider_requested: "auto",
         provider_resolved: null,
-        agent_type: 'executor',
-        transport: 'resident-pending',
+        agent_type: "executor",
+        transport: "resident-pending",
         created_at: timestamp,
         started_at: null,
         updated_at: timestamp,
         completed_at: null,
-        output: '',
-        stderr: '',
-        error: 'job not found',
+        output: "",
+        stderr: "",
+        error: "job not found",
         thread_id: null,
         session_key: null,
         conversation_open: false,
@@ -288,11 +306,17 @@ export class DelegatorService {
     }
 
     // running/queued 상태이면 worker에서 최신 상태 갱신
-    if (this.worker && (snapshot.status === 'running' || snapshot.status === 'queued')) {
+    if (
+      this.worker &&
+      (snapshot.status === "running" || snapshot.status === "queued")
+    ) {
       const workerJobId = this._workerJobMap.get(resolvedId);
       if (workerJobId) {
         try {
-          const workerResult = await this.worker.getJobStatus(workerJobId, null);
+          const workerResult = await this.worker.getJobStatus(
+            workerJobId,
+            null,
+          );
           if (workerResult && workerResult.ok !== undefined) {
             return this._applyWorkerResult(resolvedId, workerResult);
           }

package/hub/delegator/tool-definitions.mjs

@@ -1,6 +1,6 @@
-import { readFileSync } from 'node:fs';
+import { readFileSync } from "node:fs";
 
-import { DELEGATOR_SCHEMA_URL } from './contracts.mjs';
+import { DELEGATOR_SCHEMA_URL } from "./contracts.mjs";
 
 let schemaBundleCache = null;
 
@@ -14,15 +14,15 @@ export function loadDelegatorSchemaBundle() {
     return schemaBundleCache;
   }
 
-  schemaBundleCache = JSON.parse(readFileSync(DELEGATOR_SCHEMA_URL, 'utf8'));
+  schemaBundleCache = JSON.parse(readFileSync(DELEGATOR_SCHEMA_URL, "utf8"));
   return schemaBundleCache;
 }
 
 export function getDelegatorMcpToolDefinitions() {
   const bundle = loadDelegatorSchemaBundle();
   const defs = bundle.$defs || {};
-  const tools = Array.isArray(bundle['x-triflux-mcp-tools'])
-    ? bundle['x-triflux-mcp-tools']
+  const tools = Array.isArray(bundle["x-triflux-mcp-tools"])
+    ? bundle["x-triflux-mcp-tools"]
     : [];
 
   return tools.map((tool) => ({