@triflux/remote 10.53.0 → 10.55.0

package/hub/workers/codex-mcp.mjs

@@ -1,853 +0,0 @@
-// hub/workers/codex-mcp.mjs — Codex MCP 서버 래퍼
-import { appendFileSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import process from "node:process";
-import { fileURLToPath } from "node:url";
-
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-
-import { normalizeCodexProfileName } from "../../scripts/lib/codex-profile-config.mjs";
-import {
-  CODEX_MCP_EXECUTION_EXIT_CODE,
-  CODEX_MCP_TRANSPORT_EXIT_CODE,
-} from "@triflux/core/hub/cli-adapter-base.mjs";
-import { withRetry } from "./worker-utils.mjs";
-
-const REQUIRED_TOOLS = ["codex", "codex-reply"];
-
-export { CODEX_MCP_EXECUTION_EXIT_CODE, CODEX_MCP_TRANSPORT_EXIT_CODE };
-export const DEFAULT_CODEX_MCP_TIMEOUT_MS = 10 * 60 * 1000;
-export const DEFAULT_CODEX_MCP_BOOTSTRAP_TIMEOUT_MS = 120 * 1000;
-export const DEFAULT_CODEX_MCP_SHUTDOWN_TIMEOUT_MS = 2_000;
-
-/**
- * Codex MCP transport/bootstrap 계층 오류
- */
-export class CodexMcpTransportError extends Error {
-  /**
-   * @param {string} message
-   * @param {object} [options]
-   * @param {unknown} [options.cause]
-   * @param {string} [options.stderr]
-   */
-  constructor(message, options = {}) {
-    super(message, { cause: options.cause });
-    this.name = "CodexMcpTransportError";
-    this.stderr = options.stderr || "";
-  }
-}
-
-function cloneEnv(env = process.env) {
-  return Object.fromEntries(
-    Object.entries(env).filter(([, value]) => typeof value === "string"),
-  );
-}
-
-async function closeWithin(label, closeFn, timeoutMs) {
-  let timer = null;
-  try {
-    const timeout = new Promise((resolve) => {
-      timer = setTimeout(() => {
-        resolve({ timedOut: true });
-      }, timeoutMs);
-    });
-    const closed = Promise.resolve()
-      .then(closeFn)
-      .then(() => ({ timedOut: false }));
-    const result = await Promise.race([closed, timeout]);
-    if (result.timedOut) {
-      console.error(
-        `[codex-mcp] WARNING: ${label} did not close within ${timeoutMs}ms; continuing shutdown.`,
-      );
-    }
-    return result;
-  } catch (error) {
-    console.error(
-      `[codex-mcp] WARNING: ${label} close failed: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    return { timedOut: false };
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
-
-function collectTextContent(content = []) {
-  return content
-    .filter((item) => item?.type === "text" && typeof item.text === "string")
-    .map((item) => item.text)
-    .join("\n")
-    .trim();
-}
-
-function normalizeStructuredContent(structuredContent, fallbackText = "") {
-  if (!structuredContent || typeof structuredContent !== "object") {
-    return { threadId: null, content: fallbackText };
-  }
-
-  const threadId =
-    typeof structuredContent.threadId === "string"
-      ? structuredContent.threadId
-      : null;
-  const content =
-    typeof structuredContent.content === "string"
-      ? structuredContent.content
-      : fallbackText;
-
-  return { threadId, content };
-}
-
-/**
- * Read a top-level TOML scalar (`key = "value"` / `key = 'value'` /
- * `key = value`), tolerating an inline `# comment` and surrounding whitespace.
- * Returns the trimmed value, or null when the key is absent/empty. Intentionally
- * tiny — the per-profile files only carry `model` + `model_reasoning_effort`.
- *
- * @param {string} raw
- * @param {string} key
- * @returns {string|null}
- */
-function readTomlScalar(raw, key) {
-  const re = new RegExp(
-    `^\\s*${key}\\s*=\\s*(?:"([^"\\n]*)"|'([^'\\n]*)'|([^#\\n]*?))\\s*(?:#.*)?$`,
-    "m",
-  );
-  const match = raw.match(re);
-  if (!match) return null;
-  const value = (match[1] ?? match[2] ?? match[3] ?? "").trim();
-  return value || null;
-}
-
-/**
- * Resolve a Codex effort profile name (e.g. "gpt61_sol_high") to its concrete
- * `model` + reasoning effort. SSOT = the per-profile file written by
- * `tfx setup` at `~/.codex/<profile>.config.toml`. Falls back to deriving the
- * effort from the `<...>_<effort>` naming convention when the file is absent.
- *
- * codex 0.137 removed `profile` from the Codex MCP tool schema, so we translate
- * the profile into the still-accepted `model` + `config` fields instead of
- * forwarding `profile` (which now hard-fails with "unknown field `profile`").
- *
- * @param {string} profileName
- * @returns {{ model: string|null, reasoningEffort: string|null }}
- */
-export function resolveCodexProfileConfig(profileName) {
-  const result = { model: null, reasoningEffort: null };
-  if (typeof profileName !== "string" || !profileName) return result;
-  const normalizedProfileName = normalizeCodexProfileName(profileName);
-  if (!normalizedProfileName) return result;
-
-  const codexHome = process.env.CODEX_HOME || join(homedir(), ".codex");
-  try {
-    const raw = readFileSync(
-      join(codexHome, `${normalizedProfileName}.config.toml`),
-      "utf8",
-    );
-    result.model = readTomlScalar(raw, "model");
-    result.reasoningEffort = readTomlScalar(raw, "model_reasoning_effort");
-  } catch {
-    // Profile file absent (non-file alias). Derive effort from the naming
-    // convention; leave model unset so codex uses its config.toml default.
-    const suffix = /_(ultra|max|xhigh|high|med|medium|low)$/.exec(
-      normalizedProfileName,
-    );
-    if (suffix) {
-      const map = {
-        ultra: "ultra",
-        max: "max",
-        xhigh: "xhigh",
-        high: "high",
-        med: "medium",
-        medium: "medium",
-        low: "low",
-      };
-      result.reasoningEffort = map[suffix[1]] || null;
-    }
-  }
-  return result;
-}
-
-export function buildCodexArguments(prompt, opts = {}) {
-  const args = { prompt };
-
-  if (typeof opts.cwd === "string" && opts.cwd) args.cwd = opts.cwd;
-  if (typeof opts.model === "string" && opts.model) args.model = opts.model;
-  // NOTE: `profile` is intentionally NOT forwarded as a Codex tool argument.
-  // codex 0.137 dropped it from the tool schema; it is resolved into
-  // `model` + `config.model_reasoning_effort` just before return (see below).
-  if (typeof opts.approvalPolicy === "string" && opts.approvalPolicy) {
-    args["approval-policy"] = opts.approvalPolicy;
-  }
-  if (typeof opts.sandbox === "string" && opts.sandbox)
-    args.sandbox = opts.sandbox;
-  if (opts.config && typeof opts.config === "object") args.config = opts.config;
-  if (typeof opts.baseInstructions === "string" && opts.baseInstructions) {
-    args["base-instructions"] = opts.baseInstructions;
-  }
-  if (
-    typeof opts.developerInstructions === "string" &&
-    opts.developerInstructions
-  ) {
-    args["developer-instructions"] = opts.developerInstructions;
-  }
-  if (typeof opts.compactPrompt === "string" && opts.compactPrompt) {
-    args["compact-prompt"] = opts.compactPrompt;
-  }
-
-  // Map the effort profile to model + reasoning effort instead of forwarding the
-  // (0.137-rejected) `profile` field. Explicit opts.model wins over the profile;
-  // profile effort merges on top of any opts.config.
-  if (typeof opts.profile === "string" && opts.profile) {
-    const resolved = resolveCodexProfileConfig(opts.profile);
-    const profileDerivedUltra =
-      resolved.reasoningEffort?.toLowerCase() === "ultra";
-    if (typeof args.model !== "string") {
-      if (profileDerivedUltra) args.model = "gpt-6-astra";
-      else if (resolved.model) args.model = resolved.model;
-    }
-    if (resolved.reasoningEffort) {
-      args.config = {
-        ...(args.config || {}),
-        model_reasoning_effort: profileDerivedUltra
-          ? "max"
-          : resolved.reasoningEffort,
-      };
-    }
-  }
-  if (typeof opts.reasoningEffort === "string" && opts.reasoningEffort) {
-    args.config = {
-      ...(args.config || {}),
-      model_reasoning_effort: opts.reasoningEffort,
-    };
-  }
-
-  return args;
-}
-
-function pickToolName(threadId) {
-  return threadId ? "codex-reply" : "codex";
-}
-
-function withTimeout(promise, timeoutMs, message) {
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-    return promise;
-  }
-
-  let timer;
-  const timeoutPromise = new Promise((_, reject) => {
-    timer = setTimeout(() => {
-      reject(new Error(message));
-    }, timeoutMs);
-    timer.unref?.();
-  });
-
-  return Promise.race([promise, timeoutPromise]).finally(() => {
-    clearTimeout(timer);
-  });
-}
-
-// Known noise-only output patterns from codex MCP that indicate transport failure
-// despite exitCode=0. Each entry is matched after trim() against the full output
-// string. Length cap is applied separately to avoid masking real responses that
-// happen to contain a noise substring as a header line.
-const NOISE_ONLY_OUTPUT_PATTERNS = Object.freeze([
-  /^MCP issues detected\.\s*Run \/mcp list for status\.?$/i,
-]);
-const NOISE_ONLY_MAX_BYTES = 256;
-
-function isNoiseOnlyOutput(text) {
-  if (typeof text !== "string") return false;
-  const trimmed = text.trim();
-  if (!trimmed || trimmed.length > NOISE_ONLY_MAX_BYTES) return false;
-  return NOISE_ONLY_OUTPUT_PATTERNS.some((pattern) => pattern.test(trimmed));
-}
-
-// MCP tool responses are completion-buffered, so stdout cannot distinguish an
-// active long-running call from a stuck one. The SDK delivers only genuine
-// `notifications/progress` callbacks here; append one record per event for
-// tfx-route's per-run heartbeat sidecar. This is intentionally best-effort:
-// inability to write observability data must never change tool execution.
-function recordMcpProgress(activityFile) {
-  if (typeof activityFile !== "string" || !activityFile) return;
-  try {
-    appendFileSync(activityFile, "progress\n");
-  } catch {
-    // The route's liveness file is diagnostic only. A missing/readonly file
-    // must leave the normal MCP request path untouched.
-  }
-}
-
-function watchBootstrapClose(transport) {
-  let active = true;
-  const promise = new Promise((_, reject) => {
-    const priorClose = transport.onclose;
-    transport.onclose = () => {
-      priorClose?.();
-      if (active) {
-        reject(new Error("Codex MCP transport closed during bootstrap"));
-      }
-    };
-
-    const priorError = transport.onerror;
-    transport.onerror = (error) => {
-      priorError?.(error);
-      if (active) {
-        reject(error instanceof Error ? error : new Error(String(error)));
-      }
-    };
-  });
-
-  return {
-    promise,
-    stop() {
-      active = false;
-    },
-  };
-}
-
-function watchBootstrapProcessExit(transport) {
-  let active = true;
-  let timer = null;
-  let child = null;
-
-  const promise = new Promise((_, reject) => {
-    const rejectClosed = (code, signal) => {
-      if (!active) return;
-      const suffix = signal ? `signal ${signal}` : `exit ${code}`;
-      reject(
-        new Error(`Codex MCP transport closed during bootstrap (${suffix})`),
-      );
-    };
-
-    timer = setInterval(() => {
-      child = transport._process;
-      if (!child) return;
-      clearInterval(timer);
-      timer = null;
-      if (child.exitCode !== null || child.signalCode !== null) {
-        rejectClosed(child.exitCode, child.signalCode);
-        return;
-      }
-      child.once("close", rejectClosed);
-    }, 10);
-  });
-
-  return {
-    promise,
-    stop() {
-      active = false;
-      if (timer) clearInterval(timer);
-      child?.off?.("close", () => {});
-    },
-  };
-}
-
-function normalizeRetryOptions(retryOptions) {
-  if (!retryOptions || typeof retryOptions !== "object") {
-    return Object.freeze({});
-  }
-  return Object.freeze({ ...retryOptions });
-}
-
-function isCodexRetryable(error) {
-  return (
-    error instanceof CodexMcpTransportError ||
-    error?.code === "ETIMEDOUT" ||
-    error?.cause?.code === "ETIMEDOUT"
-  );
-}
-
-function detectWorkerCategory(error, fallbackCategory = "transient") {
-  const combined =
-    `${error?.message || ""}\n${error?.stderr || ""}`.toLowerCase();
-
-  if (error?.code === "INVALID_INPUT") return "input";
-  if (
-    /(unauthorized|forbidden|auth|login|token|credential|apikey|api key)/i.test(
-      combined,
-    )
-  ) {
-    return "auth";
-  }
-  if (
-    /(config|unknown option|invalid option|missing|필수 mcp 도구 누락)/i.test(
-      combined,
-    )
-  ) {
-    return "config";
-  }
-
-  return fallbackCategory;
-}
-
-function buildCodexErrorInfo(error, attempts) {
-  const retryable = isCodexRetryable(error);
-  const code =
-    error instanceof CodexMcpTransportError
-      ? "CODEX_TRANSPORT_ERROR"
-      : error?.code || "CODEX_EXECUTION_ERROR";
-  const category = detectWorkerCategory(
-    error,
-    retryable ? "transient" : "config",
-  );
-
-  let recovery =
-    "Review the Codex worker error output and retry after correcting the issue.";
-  if (code === "INVALID_INPUT") {
-    recovery = "Provide a non-empty prompt before invoking the Codex worker.";
-  } else if (retryable) {
-    recovery = "Retry after reconnecting the Codex MCP transport.";
-  } else if (category === "auth") {
-    recovery = "Refresh the Codex authentication state and retry.";
-  } else if (category === "config") {
-    recovery = "Check the Codex MCP configuration and available tools.";
-  }
-
-  return Object.freeze({
-    code,
-    retryable,
-    attempts,
-    category,
-    recovery,
-  });
-}
-
-/**
- * Codex MCP 워커
- */
-export class CodexMcpWorker {
-  type = "codex";
-
-  /**
-   * @param {object} [options]
-   * @param {string} [options.command]
-   * @param {string[]} [options.args]
-   * @param {string} [options.cwd]
-   * @param {Record<string, string>} [options.env]
-   * @param {{ name: string, version: string }} [options.clientInfo]
-   * @param {number} [options.bootstrapTimeoutMs]
-   */
-  constructor(options = {}) {
-    this.command = options.command || process.env.CODEX_BIN || "codex";
-    this.args =
-      Array.isArray(options.args) && options.args.length
-        ? [...options.args]
-        : ["mcp-server"];
-    this.cwd = options.cwd || process.cwd();
-    this.env = cloneEnv({ ...cloneEnv(process.env), ...cloneEnv(options.env) });
-    this.clientInfo = options.clientInfo || {
-      name: "triflux-codex-mcp",
-      version: "1.0.0",
-    };
-    this.bootstrapTimeoutMs = Number.isFinite(options.bootstrapTimeoutMs)
-      ? options.bootstrapTimeoutMs
-      : DEFAULT_CODEX_MCP_BOOTSTRAP_TIMEOUT_MS;
-    this.retryOptions = normalizeRetryOptions(options.retryOptions);
-    this.activityFile =
-      typeof options.activityFile === "string"
-        ? options.activityFile
-        : this.env.TFX_CODEX_MCP_ACTIVITY_FILE || "";
-
-    this.client = null;
-    this.transport = null;
-    this.ready = false;
-    this.availableTools = new Set();
-    this.threadIds = new Map();
-    this.serverStderr = "";
-  }
-
-  isReady() {
-    return this.ready;
-  }
-
-  getThreadId(sessionKey) {
-    return this.threadIds.get(sessionKey) || null;
-  }
-
-  setThreadId(sessionKey, threadId) {
-    if (!sessionKey || !threadId) return;
-    this.threadIds.set(sessionKey, threadId);
-  }
-
-  clearThread(sessionKey) {
-    if (!sessionKey) return;
-    this.threadIds.delete(sessionKey);
-  }
-
-  async start() {
-    if (this.ready && this.client && this.transport) return;
-
-    await this.stop();
-
-    const transport = new StdioClientTransport({
-      command: this.command,
-      args: this.args,
-      cwd: this.cwd,
-      env: this.env,
-      stderr: "pipe",
-    });
-    const client = new Client(this.clientInfo, { capabilities: {} });
-
-    this.serverStderr = "";
-    transport.stderr?.on("data", (chunk) => {
-      this.serverStderr += String(chunk);
-      if (this.serverStderr.length > 16000) {
-        this.serverStderr = this.serverStderr.slice(-16000);
-      }
-    });
-
-    try {
-      const bootstrapClose = watchBootstrapClose(transport);
-      const bootstrapProcessExit = watchBootstrapProcessExit(transport);
-      await withTimeout(
-        Promise.race([
-          (async () => {
-            await client.connect(transport);
-            const tools = await client.listTools(undefined, {
-              timeout: this.bootstrapTimeoutMs,
-            });
-            this.availableTools = new Set(tools.tools.map((tool) => tool.name));
-
-            for (const requiredTool of REQUIRED_TOOLS) {
-              if (!this.availableTools.has(requiredTool)) {
-                throw new Error(`필수 MCP 도구 누락: ${requiredTool}`);
-              }
-            }
-          })(),
-          bootstrapClose.promise,
-          bootstrapProcessExit.promise,
-        ]).finally(() => {
-          bootstrapClose.stop();
-          bootstrapProcessExit.stop();
-        }),
-        this.bootstrapTimeoutMs,
-        `Codex MCP bootstrap timeout (${this.bootstrapTimeoutMs}ms)`,
-      );
-    } catch (error) {
-      await client.close().catch(() => {});
-      transport.stderr?.destroy?.();
-      throw new CodexMcpTransportError(
-        `Codex MCP 연결 실패: ${error instanceof Error ? error.message : String(error)}`,
-        { cause: error, stderr: this.serverStderr.trim() },
-      );
-    }
-
-    this.client = client;
-    this.transport = transport;
-    this.ready = true;
-  }
-
-  async stop(options = {}) {
-    this.ready = false;
-    this.availableTools.clear();
-
-    const client = this.client;
-    const transport = this.transport;
-    this.transport = null;
-    this.client = null;
-
-    const shutdownTimeoutMs = Number.isFinite(options.shutdownTimeoutMs)
-      ? options.shutdownTimeoutMs
-      : DEFAULT_CODEX_MCP_SHUTDOWN_TIMEOUT_MS;
-
-    let clientCloseTimedOut = false;
-    if (client) {
-      const result = await closeWithin(
-        "client.close",
-        () => client.close(),
-        shutdownTimeoutMs,
-      );
-      clientCloseTimedOut = Boolean(result.timedOut);
-    }
-
-    if (transport && (!client || clientCloseTimedOut)) {
-      await closeWithin(
-        "transport.close",
-        () => transport.close(),
-        shutdownTimeoutMs,
-      );
-    }
-
-    transport?.stderr?.destroy?.();
-  }
-
-  /**
-   * @param {string} prompt
-   * @param {import('./interface.mjs').WorkerExecuteOptions} [opts]
-   * @returns {Promise<import('./interface.mjs').WorkerResult>}
-   */
-  async execute(prompt, opts = {}) {
-    if (typeof prompt !== "string" || !prompt.trim()) {
-      return {
-        output: "prompt는 비어 있을 수 없습니다.",
-        exitCode: CODEX_MCP_EXECUTION_EXIT_CODE,
-        threadId: null,
-        sessionKey: opts.sessionKey || null,
-        error: buildCodexErrorInfo(
-          { code: "INVALID_INPUT", message: "prompt는 비어 있을 수 없습니다." },
-          0,
-        ),
-        raw: null,
-      };
-    }
-
-    const sessionKey =
-      typeof opts.sessionKey === "string" && opts.sessionKey
-        ? opts.sessionKey
-        : null;
-
-    if (opts.resetSession && sessionKey) {
-      this.clearThread(sessionKey);
-    }
-
-    const threadId =
-      typeof opts.threadId === "string" && opts.threadId
-        ? opts.threadId
-        : sessionKey
-          ? this.getThreadId(sessionKey)
-          : null;
-    const timeoutMs = Number.isFinite(opts.timeoutMs)
-      ? opts.timeoutMs
-      : DEFAULT_CODEX_MCP_TIMEOUT_MS;
-    let attempts = 0;
-    let activeThreadId = threadId;
-
-    try {
-      const { rawResult, normalized } = await withRetry(
-        async () => {
-          attempts += 1;
-          if (attempts === 1) {
-            await this.start();
-          } else {
-            await this.stop();
-            await this.start();
-          }
-
-          const toolName = pickToolName(activeThreadId);
-          const toolArguments =
-            toolName === "codex-reply"
-              ? { prompt, threadId: activeThreadId }
-              : buildCodexArguments(prompt, opts);
-
-          const nextRawResult = await this.client.callTool(
-            { name: toolName, arguments: toolArguments },
-            undefined,
-            {
-              timeout: timeoutMs,
-              ...(this.activityFile
-                ? { onprogress: () => recordMcpProgress(this.activityFile) }
-                : {}),
-            },
-          );
-
-          const textContent = collectTextContent(nextRawResult.content);
-          const nextNormalized = normalizeStructuredContent(
-            nextRawResult.structuredContent,
-            textContent,
-          );
-          activeThreadId = nextNormalized.threadId || activeThreadId;
-
-          return { rawResult: nextRawResult, normalized: nextNormalized };
-        },
-        {
-          ...this.retryOptions,
-          shouldRetry: (error) => isCodexRetryable(error),
-        },
-      );
-
-      if (sessionKey && normalized.threadId) {
-        this.setThreadId(sessionKey, normalized.threadId);
-      }
-
-      if (rawResult.isError) {
-        return {
-          output: normalized.content,
-          exitCode: CODEX_MCP_EXECUTION_EXIT_CODE,
-          threadId: normalized.threadId,
-          sessionKey,
-          error: buildCodexErrorInfo(
-            { code: "CODEX_TOOL_ERROR", message: normalized.content },
-            attempts,
-          ),
-          raw: rawResult,
-        };
-      }
-
-      return {
-        output: normalized.content,
-        exitCode: 0,
-        threadId: normalized.threadId,
-        sessionKey,
-        raw: rawResult,
-      };
-    } catch (error) {
-      await this.stop().catch(() => {});
-      return {
-        output: error instanceof Error ? error.message : String(error),
-        exitCode: CODEX_MCP_EXECUTION_EXIT_CODE,
-        threadId: activeThreadId,
-        sessionKey,
-        error: buildCodexErrorInfo(error, attempts || 1),
-        raw: null,
-      };
-    }
-  }
-}
-
-export function createCodexMcpWorker(options = {}) {
-  return new CodexMcpWorker(options);
-}
-
-function parseCliArgs(argv) {
-  const options = {
-    command: process.env.CODEX_BIN || "codex",
-    cwd: process.cwd(),
-    timeoutMs: DEFAULT_CODEX_MCP_TIMEOUT_MS,
-  };
-
-  for (let i = 0; i < argv.length; i += 1) {
-    const token = argv[i];
-    const next = () => {
-      const value = argv[i + 1];
-      if (value === undefined) {
-        throw new Error(`${token} 값이 필요합니다.`);
-      }
-      i += 1;
-      return value;
-    };
-
-    switch (token) {
-      case "--prompt":
-        options.prompt = next();
-        break;
-      case "--thread-id":
-        options.threadId = next();
-        break;
-      case "--session-key":
-        options.sessionKey = next();
-        break;
-      case "--cwd":
-        options.cwd = next();
-        break;
-      case "--profile":
-        options.profile = next();
-        break;
-      case "--model":
-        options.model = next();
-        break;
-      case "--reasoning-effort":
-        options.reasoningEffort = next();
-        break;
-      case "--approval-policy":
-        options.approvalPolicy = next();
-        break;
-      case "--sandbox":
-        options.sandbox = next();
-        break;
-      case "--base-instructions":
-        options.baseInstructions = next();
-        break;
-      case "--developer-instructions":
-        options.developerInstructions = next();
-        break;
-      case "--compact-prompt":
-        options.compactPrompt = next();
-        break;
-      case "--timeout-ms":
-        options.timeoutMs = Number.parseInt(next(), 10);
-        break;
-      case "--config-json":
-        options.config = JSON.parse(next());
-        break;
-      case "--codex-command":
-        options.command = next();
-        break;
-      case "--reset-session":
-        options.resetSession = true;
-        break;
-      default:
-        throw new Error(`알 수 없는 옵션: ${token}`);
-    }
-  }
-
-  if (typeof options.prompt !== "string" || !options.prompt) {
-    throw new Error("--prompt는 필수입니다.");
-  }
-
-  return options;
-}
-
-export async function runCodexMcpCli(argv = process.argv.slice(2)) {
-  let options;
-  try {
-    options = parseCliArgs(argv);
-  } catch (error) {
-    console.error(
-      `[codex-mcp] ${error instanceof Error ? error.message : String(error)}`,
-    );
-    process.exitCode = 64;
-    return;
-  }
-
-  const worker = new CodexMcpWorker({
-    command: options.command,
-    cwd: options.cwd,
-    retryOptions: { maxAttempts: 1 },
-  });
-
-  try {
-    const result = await worker.execute(options.prompt, options);
-    const hasOutput =
-      typeof result.output === "string" && result.output.trim().length > 0;
-    const noiseOnly = hasOutput && isNoiseOnlyOutput(result.output);
-    if (hasOutput) {
-      process.stdout.write(result.output);
-      if (!result.output.endsWith("\n")) {
-        process.stdout.write("\n");
-      }
-    }
-    // Silent-success regression guard (codex 0.124.0+):
-    // codex MCP can return exitCode=0 with empty/whitespace `output` when the
-    // result-extraction path fails to read the assistant content from the MCP
-    // response. Without this guard, tfx-route.sh sees STDOUT_LOG=0 bytes and
-    // treats it as success — caller gets nothing back.
-    // Promote to a transport failure so the wrapper falls back to `codex exec`.
-    //
-    // Noise-only guard (codex 0.125.0+, P2 swarm signature):
-    // codex MCP can also return exitCode=0 with a short noise-only message like
-    // "MCP issues detected. Run /mcp list for status." (~48 bytes) instead of
-    // an actual response payload. trim().length > 0 passes the empty-output
-    // check, so the previous guard misses this case. Pattern-match known noise
-    // strings under a small length cap and promote to transport failure too.
-    if (result.error?.code === "CODEX_TRANSPORT_ERROR") {
-      process.exitCode = CODEX_MCP_TRANSPORT_EXIT_CODE;
-    } else if (!hasOutput && result.exitCode === 0) {
-      console.error(
-        "[codex-mcp] WARNING: empty output with exit 0 — treating as transport failure (codex 0.124.0 silent-flush regression). Wrapper will fall back to exec path.",
-      );
-      process.exitCode = CODEX_MCP_TRANSPORT_EXIT_CODE;
-    } else if (noiseOnly && result.exitCode === 0) {
-      console.error(
-        "[codex-mcp] WARNING: noise-only output (codex MCP error string without payload) with exit 0 — treating as transport failure. Wrapper will fall back to exec path.",
-      );
-      process.exitCode = CODEX_MCP_TRANSPORT_EXIT_CODE;
-    } else {
-      process.exitCode = result.exitCode;
-    }
-  } catch (error) {
-    const lines = [error instanceof Error ? error.message : String(error)];
-    if (error instanceof CodexMcpTransportError && error.stderr) {
-      lines.push(error.stderr);
-    }
-    console.error(`[codex-mcp] ${lines.join("\n")}`);
-    process.exitCode = CODEX_MCP_TRANSPORT_EXIT_CODE;
-  } finally {
-    await worker.stop();
-  }
-}
-
-if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
-  await runCodexMcpCli();
-  process.exit(process.exitCode ?? 0);
-}