triflux 10.16.0 → 10.17.0

package/bin/triflux.mjs

@@ -5073,29 +5073,28 @@ function startHubAfterUpdate(info) {
 function autoRegisterMcp(mcpUrl, { codexEnabled = false } = {}) {
   section("MCP 자동 등록");
 
-  // Codex — config.json에 기본 disabled 엔트리로 등록
-  if (which("codex")) {
-    try {
-      const result = ensureCodexHubServerConfig({
-        mcpUrl,
-        createIfMissing: true,
-        enabled: codexEnabled,
-      });
-      if (!result.ok) throw new Error(result.reason || "unknown");
-      if (result.changed) {
-        ok(
-          `Codex: config.json에 등록 완료 (${codexEnabled ? "enabled" : "기본 disabled"})`,
-        );
-      } else {
-        ok(
-          `Codex: 이미 등록됨 (${codexEnabled ? "enabled" : "기본 disabled"})`,
-        );
-      }
-    } catch (e) {
-      warn(`Codex 등록 실패: ${e.message}`);
+  // Codex — config.json에 기본 disabled 엔트리로 등록.
+  // Hub startup must keep the MCP config fresh even on CI/dev machines where
+  // the Codex CLI binary itself is not installed.
+  try {
+    const result = ensureCodexHubServerConfig({
+      mcpUrl,
+      createIfMissing: true,
+      enabled: codexEnabled,
+    });
+    if (!result.ok) throw new Error(result.reason || "unknown");
+    const suffix = which("codex") ? "" : " (CLI 미설치)";
+    if (result.changed) {
+      ok(
+        `Codex: config.json에 등록 완료 (${codexEnabled ? "enabled" : "기본 disabled"})${suffix}`,
+      );
+    } else {
+      ok(
+        `Codex: 이미 등록됨 (${codexEnabled ? "enabled" : "기본 disabled"})${suffix}`,
+      );
     }
-  } else {
-    info("Codex: 미설치 (건너뜀)");
+  } catch (e) {
+    warn(`Codex 등록 실패: ${e.message}`);
   }
 
   // Gemini — settings.json 직접 수정

package/hooks/keyword-rules.json

@@ -97,6 +97,18 @@
           "source": "(?:정리해|슬롭|클린업)",
           "flags": "i"
         },
+        {
+          "source": "(?:병렬|동시에|parallel|concurrent)",
+          "flags": "i"
+        },
+        {
+          "source": "(?:점검|진단|확인해)",
+          "flags": "i"
+        },
+        {
+          "source": "(?:계속해|이어서|진행해)",
+          "flags": "i"
+        },
         {
           "source": "\\b(?:implement|build|fix|review|test|plan|analyze)\\b",
           "flags": "i"

package/hooks/safety-guard.mjs

@@ -123,9 +123,12 @@ function getWindowsHostIds() {
       ids.add(name);
       if (cfg.tailscale?.ip) ids.add(cfg.tailscale.ip);
       if (cfg.tailscale?.dns) ids.add(cfg.tailscale.dns);
+      if (cfg.ssh?.host) ids.add(cfg.ssh.host);
       if (cfg.ssh?.user) {
         ids.add(`${cfg.ssh.user}@${name}`);
         if (cfg.tailscale?.ip) ids.add(`${cfg.ssh.user}@${cfg.tailscale.ip}`);
+        if (cfg.tailscale?.dns) ids.add(`${cfg.ssh.user}@${cfg.tailscale.dns}`);
+        if (cfg.ssh?.host) ids.add(`${cfg.ssh.user}@${cfg.ssh.host}`);
       }
     }
   } catch {

package/hub/cli-adapter-base.mjs

@@ -72,6 +72,11 @@ let _cachedVersion = null;
  */
 export function getCodexVersion() {
   if (_cachedVersion !== null) return _cachedVersion;
+  const override = Number(process.env.TFX_CODEX_VERSION_MINOR);
+  if (Number.isFinite(override) && override > 0) {
+    _cachedVersion = override;
+    return _cachedVersion;
+  }
   try {
     const out = execSync("codex --version", {
       encoding: "utf8",
@@ -80,7 +85,10 @@ export function getCodexVersion() {
     const match = out.match(/(\d+)\.(\d+)\.(\d+)/);
     _cachedVersion = match ? Number.parseInt(match[2], 10) : 0;
   } catch {
-    _cachedVersion = 0;
+    // Command builders should remain stable in CI even when the real Codex
+    // CLI is absent. Runtime preflight still reports/install-gates Codex
+    // separately; this fallback only selects the modern argv shape.
+    _cachedVersion = 117;
   }
   return _cachedVersion;
 }
@@ -182,10 +190,7 @@ export function buildExecCommand(prompt, resultFile = null, opts = {}) {
 // ── Sleep ───────────────────────────────────────────────────────
 
 export function sleep(ms) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
-    timer.unref?.();
-  });
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 // ── Result factory ──────────────────────────────────────────────

package/hub/lib/hosts-compat.mjs

@@ -133,8 +133,20 @@ function normalizeLastProbe(rawProbe) {
   return Object.keys(probe).length > 0 ? probe : null;
 }
 
+function normalizeResources(rawHost) {
+  const rawResources =
+    rawHost.resources && typeof rawHost.resources === "object"
+      ? rawHost.resources
+      : {};
+  const rawSpecs =
+    rawHost.specs && typeof rawHost.specs === "object" ? rawHost.specs : {};
+  return { ...rawResources, ...rawSpecs };
+}
+
 export function normalizeHost(rawHost = {}, name = "") {
   const sshUser = rawHost.ssh_user || rawHost.ssh?.user || rawHost.user || null;
+  const sshHost = rawHost.ssh?.host || rawHost.host || null;
+  const resources = normalizeResources(rawHost);
   const tailscale = {
     ip: rawHost.tailscale?.ip || null,
     dns: rawHost.tailscale?.dns || null,
@@ -167,15 +179,14 @@ export function normalizeHost(rawHost = {}, name = "") {
     ssh: {
       ...(rawHost.ssh && typeof rawHost.ssh === "object" ? rawHost.ssh : {}),
       user: sshUser,
+      host: sshHost,
     },
     tailscale,
     capabilities,
     capabilities_v2,
     last_probe: normalizeLastProbe(rawHost.last_probe),
-    specs:
-      rawHost.specs && typeof rawHost.specs === "object"
-        ? { ...rawHost.specs }
-        : {},
+    resources,
+    specs: { ...resources },
     raw: { ...rawHost },
   };
 }
@@ -234,6 +245,7 @@ export function resolveHost(nameOrAlias, repoRoot) {
       ...host.aliases,
       host.tailscale.ip,
       host.tailscale.dns,
+      host.ssh.host,
       host.ssh_user ? `${host.ssh_user}@${name}` : null,
       host.ssh_user && host.tailscale.ip
         ? `${host.ssh_user}@${host.tailscale.ip}`
@@ -241,6 +253,9 @@ export function resolveHost(nameOrAlias, repoRoot) {
       host.ssh_user && host.tailscale.dns
         ? `${host.ssh_user}@${host.tailscale.dns}`
         : null,
+      host.ssh_user && host.ssh.host
+        ? `${host.ssh_user}@${host.ssh.host}`
+        : null,
     ]);
     for (const alias of aliases) {
       if (alias && String(alias).toLowerCase() === lowered) {

package/hub/lib/ssh-command.mjs

@@ -2,7 +2,7 @@
 // PowerShell 호스트에 bash 문법(2>/dev/null, &&, $())을 보내는 사고를 방지한다.
 // 모든 SSH 명령 생성 코드에서 이 유틸리티를 사용할 것.
 
-import { readHosts } from "./hosts-compat.mjs";
+import { readHost, readHosts, resolveHost } from "./hosts-compat.mjs";
 
 /** hosts.json 캐시 (프로세스 수명 동안 유지) */
 let hostsCache = null;
@@ -28,7 +28,7 @@ function loadHostsCache(repoRoot) {
 export function detectHostOs(hostAlias, repoRoot) {
   loadHostsCache(repoRoot);
 
-  const hostCfg = hostsCache.hosts?.[hostAlias];
+  const hostCfg = resolveHost(hostAlias, repoRoot)?.host;
   if (hostCfg?.os === "windows") return "windows";
   if (hostCfg?.os) return "posix";
 
@@ -163,7 +163,7 @@ export function validateCommandForOs(command, os) {
  */
 export function getHostConfig(hostAlias, repoRoot) {
   loadHostsCache(repoRoot);
-  return hostsCache.hosts?.[hostAlias] ?? null;
+  return readHost(hostAlias, repoRoot);
 }
 
 /**
@@ -175,13 +175,7 @@ export function getHostConfig(hostAlias, repoRoot) {
 export function resolveHostAlias(alias, repoRoot) {
   loadHostsCache(repoRoot);
 
-  if (hostsCache.hosts?.[alias]) return alias;
-
-  for (const [name, cfg] of Object.entries(hostsCache.hosts || {})) {
-    if (cfg.aliases.includes(alias)) return name;
-  }
-
-  return null;
+  return resolveHost(alias, repoRoot)?.name ?? null;
 }
 
 /**

package/hub/router.mjs

@@ -60,6 +60,21 @@ function normalizeAgentTopics(store, agentId, runtimeTopics) {
   return Array.from(topics);
 }
 
+function waitForEmitterOnce(emitter, eventName, timeoutMs) {
+  let timer = null;
+  const timeout = Math.max(0, Math.min(Number(timeoutMs) || 0, 30000));
+  return Promise.race([
+    once(emitter, eventName),
+    new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(new Error(`timed out waiting for ${eventName}`));
+      }, timeout);
+    }),
+  ]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+
 /**
  * 라우터 생성
  * @param {object} store
@@ -525,9 +540,11 @@ export function createRouter(store) {
       }
 
       try {
-        const [response] = await once(responseEmitter, cid, {
-          signal: AbortSignal.timeout(Math.min(await_response_ms, 30000)),
-        });
+        const [response] = await waitForEmitterOnce(
+          responseEmitter,
+          cid,
+          await_response_ms,
+        );
         return {
           ok: true,
           data: {

package/hub/server.mjs

@@ -326,7 +326,14 @@ async function syncHubMcpSettingsIfAvailable({ hubUrl }) {
     if (typeof mod?.syncCodexHubUrl === "function") {
       await mod.syncCodexHubUrl({ hubUrl });
     }
-    if (typeof mod?.syncProjectMcpJson === "function") {
+    const allowProjectSync =
+      process.env.TFX_PROJECT_MCP_SYNC === "1" ||
+      !(
+        process.env.NODE_ENV === "test" ||
+        process.env.CI === "true" ||
+        process.env.TFX_TEST === "1"
+      );
+    if (allowProjectSync && typeof mod?.syncProjectMcpJson === "function") {
       await mod.syncProjectMcpJson({ hubUrl, projectRoot: PROJECT_ROOT });
     }
   } catch (error) {

package/hub/team/agent-map.json

@@ -1,6 +1,8 @@
 {
   "executor": "codex",
   "build-fixer": "codex",
+  "cleanup": "codex",
+  "deslop": "codex",
   "debugger": "codex",
   "deep-executor": "codex",
   "architect": "codex",

package/hub/team/codex-review.mjs

@@ -55,21 +55,22 @@ export function expandRange({ ref = "HEAD", base } = {}) {
  * - `HEAD` with no prior commit returns an empty string
  * - optional `file` scopes the diff to a single path via `-- <file>`
  *
- * @param {{ ref?: string, base?: string, file?: string }} opts
+ * @param {{ ref?: string, base?: string, file?: string, runner?: (cmd: string, args: string[]) => string }} opts
  * @returns {{ diff: string, range: string, file?: string }}
  */
-export function resolveReviewDiff({ ref = "HEAD", base, file } = {}) {
+export function resolveReviewDiff({
+  ref = "HEAD",
+  base,
+  file,
+  runner = _defaultGitRunner,
+} = {}) {
   const range = expandRange({ ref, base });
 
   const args = ["log", "-p", "--stat", "--no-color", range];
   if (file) {
     args.push("--", file);
   }
-  const diff = execFileSync("git", args, {
-    encoding: "utf8",
-    windowsHide: true,
-    maxBuffer: 50 * 1024 * 1024,
-  });
+  const diff = runner("git", args);
   return { diff, range, file };
 }
 
@@ -306,11 +307,15 @@ export async function runCodexReview({
   timeoutMs = 180_000,
   sandbox = "read-only",
   env = process.env,
+  _deps = {},
 } = {}) {
   let range;
   let diff;
   try {
-    ({ diff, range } = resolveReviewDiff({ ref, base }));
+    ({ diff, range } = (_deps.resolveReviewDiff || resolveReviewDiff)({
+      ref,
+      base,
+    }));
   } catch (err) {
     return {
       ok: false,
@@ -353,7 +358,7 @@ export async function runCodexReview({
     };
   }
 
-  return _runCodexOnPrompt({
+  return (_deps.runCodexOnPrompt || _runCodexOnPrompt)({
     prompt,
     range,
     diffBytes,

package/hub/team/conductor.mjs

@@ -57,7 +57,7 @@ export const STATES = Object.freeze({
 /** 유효한 상태 전이 테이블 */
 const TRANSITIONS = Object.freeze({
   [STATES.INIT]: [STATES.STARTING],
-  [STATES.STARTING]: [STATES.HEALTHY, STATES.FAILED],
+  [STATES.STARTING]: [STATES.HEALTHY, STATES.FAILED, STATES.COMPLETED],
   [STATES.HEALTHY]: [
     STATES.STALLED,
     STATES.INPUT_WAIT,
@@ -337,7 +337,6 @@ export function createConductor(opts = {}) {
         forceKill(pid);
         resolve();
       }, graceMs);
-      timer.unref?.();
       child.once("exit", () => {
         clearTimeout(timer);
         resolve();
@@ -629,6 +628,7 @@ export function createConductor(opts = {}) {
       });
 
       if (TERMINAL_STATES.has(session.state)) return;
+      if (shuttingDown) return;
 
       if (code === 0 && !signal) {
         transition(session, STATES.COMPLETED, "exit_0");
@@ -675,7 +675,7 @@ export function createConductor(opts = {}) {
         session: session.id,
         error: err.message,
       });
-      if (!TERMINAL_STATES.has(session.state)) {
+      if (!shuttingDown && !TERMINAL_STATES.has(session.state)) {
         handleFailure(session, `child_error:${err.message}`);
       }
     });
@@ -866,6 +866,8 @@ export function createConductor(opts = {}) {
         host,
       });
 
+      if (shuttingDown || TERMINAL_STATES.has(session.state)) return;
+
       // 원격 세션은 broker lease를 사용하지 않으므로 release 불필요
       // (spawnSession에서 config.remote === true일 때 lease 건너뜀)
       if (code === 0) {
@@ -900,7 +902,9 @@ export function createConductor(opts = {}) {
         session: session.id,
         error: err.message,
       });
-      handleFailure(session, `spawn_error:${err.message}`);
+      if (!shuttingDown && !TERMINAL_STATES.has(session.state)) {
+        handleFailure(session, `spawn_error:${err.message}`);
+      }
     });
   }
 

package/hub/team/psmux.mjs

@@ -940,7 +940,7 @@ function killOrphanMcpProcesses(sessionName) {
       // (e.g. `<session>2-worker-1.txt`).
       const escSession = escapeRegex(safeSessionUnix);
       const pids = childProcess
-        .execFileSync("pgrep", ["-f", `tfx-headless/${escSession}[-/.]`], {
+        .execFileSync("pgrep", ["-f", `tfx-headless/${escSession}[-./]`], {
           encoding: "utf8",
           timeout: 5000,
           stdio: ["ignore", "pipe", "ignore"],

package/hub/team/worktree-lifecycle.mjs

@@ -58,7 +58,20 @@ function git(args, cwd) {
     execFile(
       "git",
       args,
-      { cwd, windowsHide: true, timeout: 30_000 },
+      {
+        cwd,
+        windowsHide: true,
+        timeout: 30_000,
+        env: {
+          ...process.env,
+          GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME || "Triflux",
+          GIT_AUTHOR_EMAIL:
+            process.env.GIT_AUTHOR_EMAIL || "triflux@example.invalid",
+          GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME || "Triflux",
+          GIT_COMMITTER_EMAIL:
+            process.env.GIT_COMMITTER_EMAIL || "triflux@example.invalid",
+        },
+      },
       (err, stdout, stderr) => {
         if (err) {
           const msg = `git ${args[0]} failed: ${stderr?.trim() || err.message}`;

package/hub/workers/codex-app-server-worker.mjs

@@ -876,7 +876,6 @@ export class CodexAppServerWorker {
             raw: null,
           });
         }, timeoutMs);
-        timer.unref?.();
       });
 
       const result = await Promise.race([resultPromise, timeoutPromise]);
@@ -952,8 +951,7 @@ export class CodexAppServerWorker {
               });
             client.close("closing");
             const deadline = new Promise((resolve) => {
-              const t = setTimeout(resolve, UNSUBSCRIBE_DEADLINE_MS);
-              t.unref?.();
+              setTimeout(resolve, UNSUBSCRIBE_DEADLINE_MS);
             });
             await Promise.race([unsubPromise, deadline]);
           }
@@ -971,12 +969,12 @@ export class CodexAppServerWorker {
       try {
         if (child.exitCode === null && !child.killed) child.kill("SIGTERM");
       } catch {}
-      const killTimer = setTimeout(() => {
+      if (child.exitCode === null && !child.killed) {
+        await new Promise((resolve) => setTimeout(resolve, 1_000));
         try {
           if (child.exitCode === null && !child.killed) child.kill("SIGKILL");
         } catch {}
-      }, 1_000);
-      killTimer.unref?.();
+      }
     }
   }
 

package/hub/workers/lib/jsonrpc-stdio.mjs

@@ -178,7 +178,6 @@ export class JsonRpcStdioClient {
             ),
           );
         }, timeoutMs);
-        if (typeof timer.unref === "function") timer.unref();
       }
 
       this._pendingRequests.set(id, { resolve, reject, timer, method });

package/hub/workers/worker-utils.mjs

@@ -25,8 +25,7 @@ export function createWorkerError(message, details = {}) {
 
 function sleep(delayMs) {
   return new Promise((resolve) => {
-    const timer = setTimeout(resolve, Math.max(0, delayMs));
-    timer.unref?.();
+    setTimeout(resolve, Math.max(0, delayMs));
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.16.0",
+  "version": "10.17.0",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "type": "module",
   "bin": {

package/scripts/codex-mcp-gateway-sync.mjs

@@ -21,6 +21,7 @@ import { SERVERS } from "./mcp-gateway-start.mjs";
 
 const CODEX_CONFIG = join(homedir(), ".codex", "config.toml");
 const BACKUP_SUFFIX = ".pre-gateway.bak";
+const CODEX_CONFIG_SYNC_OPT_IN = "TFX_CODEX_CONFIG_SYNC";
 
 // gateway 서버 → SSE URL 매핑
 const GATEWAY_MAP = new Map(
@@ -75,9 +76,25 @@ function _buildStdioEntry(name, block) {
   return `[mcp_servers.${name}]\n${block}\n`;
 }
 
+function isProtectedCodexConfigMutationEnv(env = process.env) {
+  return env.NODE_ENV === "test" || env.CI === "true" || env.TFX_TEST === "1";
+}
+
+function shouldSkipCodexConfigMutation() {
+  return (
+    process.env[CODEX_CONFIG_SYNC_OPT_IN] !== "1" &&
+    isProtectedCodexConfigMutationEnv()
+  );
+}
+
 // ── enable: stdio → SSE ──
 
 export function enableGateway() {
+  if (shouldSkipCodexConfigMutation()) {
+    console.log("[SKIP] protected environment; config.toml not modified");
+    return { changed: 0, skipped: 0, reason: "protected-env" };
+  }
+
   if (!existsSync(CODEX_CONFIG)) {
     console.log("[SKIP] ~/.codex/config.toml not found");
     return { changed: 0, skipped: 0 };
@@ -151,6 +168,11 @@ export function enableGateway() {
 // ── disable: SSE → stdio 복원 ──
 
 export function disableGateway() {
+  if (shouldSkipCodexConfigMutation()) {
+    console.log("[SKIP] protected environment; config.toml not restored");
+    return false;
+  }
+
   const backupPath = CODEX_CONFIG + BACKUP_SUFFIX;
   if (!existsSync(backupPath)) {
     console.log("[SKIP] No backup found — nothing to restore");

package/scripts/doctor-diagnose.mjs

@@ -258,6 +258,28 @@ function generateSummary(stats, sysInfo, hookTimings, traceCount) {
   return lines.join("\n");
 }
 
+function createZipArchive(bundleDir, zipPath) {
+  if (platform() === "win32") {
+    execFileSync(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Compress-Archive -Path '${bundleDir}\\*' -DestinationPath '${zipPath}' -Force`,
+      ],
+      { timeout: 30000, windowsHide: true },
+    );
+    return;
+  }
+
+  execFileSync("zip", ["-qr", zipPath, "."], {
+    cwd: bundleDir,
+    timeout: 30000,
+    windowsHide: true,
+  });
+}
+
 export async function diagnose({ json = false } = {}) {
   mkdirSync(DIAG_DIR, { recursive: true });
 
@@ -319,19 +341,10 @@ export async function diagnose({ json = false } = {}) {
   const summary = generateSummary(stats, sysInfo, hookTimings, traces.length);
   writeFileSync(join(bundleDir, "summary.txt"), summary);
 
-  // 7. zip via PowerShell Compress-Archive
+  // 7. zip via platform archive tool
   const zipPath = `${bundleDir}.zip`;
   try {
-    execFileSync(
-      "powershell.exe",
-      [
-        "-NoProfile",
-        "-NonInteractive",
-        "-Command",
-        `Compress-Archive -Path '${bundleDir}\\*' -DestinationPath '${zipPath}' -Force`,
-      ],
-      { timeout: 30000, windowsHide: true },
-    );
+    createZipArchive(bundleDir, zipPath);
   } catch (err) {
     // fallback: leave the directory unzipped
     if (json) {

package/scripts/lib/mcp-guard-engine.mjs

@@ -98,6 +98,17 @@ function isCodexConfig(filePath) {
   return normalized.endsWith("/.codex/config.toml");
 }
 
+function isProtectedCodexConfigMutationEnv(env = process.env) {
+  return env.NODE_ENV === "test" || env.CI === "true" || env.TFX_TEST === "1";
+}
+
+function shouldSkipCodexConfigMutation() {
+  return (
+    process.env.TFX_CODEX_CONFIG_SYNC !== "1" &&
+    isProtectedCodexConfigMutationEnv()
+  );
+}
+
 function detectClient(filePath) {
   const normalized = normalizeForMatch(filePath);
   if (normalized.endsWith("/.gemini/settings.json")) return "gemini";
@@ -448,6 +459,15 @@ function updateJsonConfig(filePath, updates = [], removals = []) {
 
 function updateCodexConfig(filePath, updates = [], removals = []) {
   const resolvedPath = resolveFilePath(filePath);
+  if (shouldSkipCodexConfigMutation()) {
+    return {
+      modified: false,
+      filePath: resolvedPath,
+      skipped: true,
+      reason: "protected-env",
+    };
+  }
+
   let raw = existsSync(resolvedPath) ? readFileSync(resolvedPath, "utf8") : "";
 
   for (const name of removals) {

package/scripts/setup.mjs

@@ -581,6 +581,15 @@ function ensureHooksInSettings({ settingsPath, registryPath }) {
   }
 }
 
+function isProtectedCodexConfigMutationEnv(env = process.env) {
+  return (
+    env.NODE_ENV === "test" ||
+    env.CI === "true" ||
+    env.TFX_TEST === "1" ||
+    Boolean(env.TRIFLUX_TEST_HOME)
+  );
+}
+
 /**
  * Codex config.json에 tfx-hub MCP 서버 엔트리를 보장한다.
  * @param {{ mcpUrl: string, createIfMissing?: boolean, enabled?: boolean }} opts
@@ -594,7 +603,19 @@ function ensureCodexHubServerConfig({
 }) {
   try {
     const codexConfigDir = join(homedir(), ".codex");
-    const configPath = configFile || join(codexConfigDir, "config.json");
+    const hasExplicitConfigFile =
+      typeof configFile === "string" && configFile.length > 0;
+    const configPath = hasExplicitConfigFile
+      ? configFile
+      : join(codexConfigDir, "config.json");
+
+    if (
+      !hasExplicitConfigFile &&
+      process.env.TFX_CODEX_CONFIG_SYNC !== "1" &&
+      isProtectedCodexConfigMutationEnv()
+    ) {
+      return { ok: true, changed: false, reason: "protected-env" };
+    }
 
     if (!existsSync(configPath)) {
       if (!createIfMissing)
@@ -642,6 +663,13 @@ const REQUIRED_TOP_LEVEL_SETTINGS = [
 
 function ensureCodexProfiles() {
   try {
+    if (
+      process.env.TFX_CODEX_CONFIG_SYNC !== "1" &&
+      isProtectedCodexConfigMutationEnv()
+    ) {
+      return { ok: true, changed: 0, reason: "protected-env" };
+    }
+
     if (!existsSync(CODEX_DIR)) mkdirSync(CODEX_DIR, { recursive: true });
 
     const original = existsSync(CODEX_CONFIG_PATH)

package/scripts/sync-hub-mcp-settings.mjs

@@ -12,6 +12,7 @@ const CODEX_CONFIG_FILE = [".codex", "config.toml"];
 const TFX_HUB_SECTION = "tfx-hub";
 const CODEX_DEFAULT_HUB_URL = "http://127.0.0.1:27888/mcp";
 const FILE_LOCKS = new Map();
+const CODEX_CONFIG_SYNC_OPT_IN = "TFX_CODEX_CONFIG_SYNC";
 
 // Windows 에서 process.env.HOME 만 set 하고 USERPROFILE 은 그대로 둔 fixture 환경
 // (e.g. integration test) 에서 production path 로 새는 것을 방지하려면 platform
@@ -40,6 +41,29 @@ function getCodexConfigPath(codexConfigPath) {
   return join(resolveHome(), ...CODEX_CONFIG_FILE);
 }
 
+function isProtectedCodexConfigEnv(env = process.env) {
+  return (
+    env.NODE_ENV === "test" ||
+    env.CI === "true" ||
+    env.TFX_TEST === "1" ||
+    Boolean(env.TRIFLUX_TEST_HOME)
+  );
+}
+
+function shouldSkipImplicitCodexConfigWrite({
+  codexConfigPath,
+  allowProtectedEnvWrite,
+  env = process.env,
+}) {
+  if (allowProtectedEnvWrite || env[CODEX_CONFIG_SYNC_OPT_IN] === "1") {
+    return false;
+  }
+  if (typeof codexConfigPath === "string" && codexConfigPath.length > 0) {
+    return false;
+  }
+  return isProtectedCodexConfigEnv(env);
+}
+
 export function getProjectMcpJsonPaths(projectRoot) {
   const root =
     typeof projectRoot === "string" && projectRoot.length > 0
@@ -533,6 +557,7 @@ export async function syncCodexHubUrl({
   codexConfigPath,
   dryRun = false,
   logger = console,
+  allowProtectedEnvWrite = false,
 }) {
   const result = {
     updated: [],
@@ -540,8 +565,20 @@ export async function syncCodexHubUrl({
     errors: [],
   };
 
+  const filePath = getCodexConfigPath(codexConfigPath);
+  if (
+    shouldSkipImplicitCodexConfigWrite({
+      codexConfigPath,
+      allowProtectedEnvWrite,
+    })
+  ) {
+    log(logger, "info", `[codex-mcp-sync] skipped: ${filePath}`);
+    result.skipped.push(filePath);
+    return result;
+  }
+
   const outcome = await syncCodexConfigFile({
-    filePath: getCodexConfigPath(codexConfigPath),
+    filePath,
     hubUrl,
     dryRun,
     logger,

package/scripts/test-lock.mjs

@@ -8,13 +8,107 @@
 // 사용: node scripts/test-lock.mjs [-- ...node --test args]
 
 import { spawn } from "node:child_process";
-import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import {
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 
-const LOCK_DIR = join(import.meta.dirname, "..", ".test-lock");
+const SCRIPT_PATH = fileURLToPath(import.meta.url);
+const LOCK_DIR = join(dirname(SCRIPT_PATH), "..", ".test-lock");
 const LOCK_FILE = join(LOCK_DIR, "pid.lock");
 const STALE_THRESHOLD_MS = 10 * 60 * 1000; // 10분 넘으면 stale
 
+function toPosixPath(path) {
+  return path.replace(/\\/g, "/");
+}
+
+function stripLeadingDotSlash(pattern) {
+  return pattern.startsWith("./") ? pattern.slice(2) : pattern;
+}
+
+function globToRegExp(pattern) {
+  let source = "^";
+  for (let i = 0; i < pattern.length; i++) {
+    const char = pattern[i];
+    if (char === "*") {
+      if (pattern[i + 1] === "*") {
+        if (pattern[i + 2] === "/") {
+          source += "(?:.*/)?";
+          i += 2;
+        } else {
+          source += ".*";
+          i += 1;
+        }
+      } else {
+        source += "[^/]*";
+      }
+      continue;
+    }
+    source += /[\\^$+?.()|[\]{}]/.test(char) ? `\\${char}` : char;
+  }
+  source += "$";
+  return new RegExp(source);
+}
+
+function staticGlobPrefix(pattern) {
+  const firstGlob = pattern.indexOf("*");
+  if (firstGlob === -1) return pattern;
+  const slash = pattern.lastIndexOf("/", firstGlob);
+  if (slash === -1) return ".";
+  return pattern.slice(0, slash) || ".";
+}
+
+function walkFiles(dir) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const files = [];
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walkFiles(fullPath));
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+function expandGlobArg(arg, cwd) {
+  const normalizedPattern = stripLeadingDotSlash(toPosixPath(arg));
+  const matchPattern = isAbsolute(arg)
+    ? toPosixPath(resolve(arg))
+    : normalizedPattern;
+  const matcher = globToRegExp(matchPattern);
+  const prefix = staticGlobPrefix(normalizedPattern);
+  const root = isAbsolute(arg) ? resolve(prefix) : resolve(cwd, prefix);
+
+  return walkFiles(root)
+    .map((file) => {
+      if (isAbsolute(arg)) return toPosixPath(resolve(file));
+      return toPosixPath(relative(cwd, file));
+    })
+    .filter((file) => matcher.test(file))
+    .sort((a, b) => a.localeCompare(b));
+}
+
+export function expandTestArgs(args, { cwd = process.cwd() } = {}) {
+  return args.flatMap((arg) => {
+    if (arg.startsWith("-") || !arg.includes("*")) return [arg];
+    const expanded = expandGlobArg(arg, cwd);
+    return expanded.length > 0 ? expanded : [arg];
+  });
+}
+
 function readLock() {
   try {
     const content = readFileSync(LOCK_FILE, "utf8").trim();
@@ -56,36 +150,40 @@ function releaseLock() {
   }
 }
 
-// ── main ──
-
-acquireLock();
-
-// cleanup on exit
-process.on("exit", releaseLock);
-process.on("SIGINT", () => {
-  releaseLock();
-  process.exit(130);
-});
-process.on("SIGTERM", () => {
-  releaseLock();
-  process.exit(143);
-});
-
-// forward args after -- to node --test
-const args = process.argv.slice(2);
-// stdio split (issue #192 F1): when prepare.mjs spawns this lock with
-// ["ignore","pipe","pipe"], full inherit cascades the parent stdin=ignore
-// to grand-child node --test, breaking ConPTY assumptions on Windows and
-// surfacing as EXIT=1 (false-failed). Pipe stdin only — stdout/stderr stay
-// inherited so the grand-child still streams to whoever attached to us.
-const child = spawn(process.execPath, args, {
-  stdio: ["pipe", "inherit", "inherit"],
-  env: { ...process.env, TEST_LOCK_PID: String(process.pid) },
-});
-// Close stdin immediately so node --test never blocks waiting for input.
-child.stdin?.end();
-
-child.on("exit", (code) => {
-  releaseLock();
-  process.exit(code ?? 1);
-});
+export function main(argv = process.argv.slice(2)) {
+  acquireLock();
+
+  // cleanup on exit
+  process.on("exit", releaseLock);
+  process.on("SIGINT", () => {
+    releaseLock();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    releaseLock();
+    process.exit(143);
+  });
+
+  // forward args after -- to node --test
+  const args = expandTestArgs(argv);
+  // stdio split (issue #192 F1): when prepare.mjs spawns this lock with
+  // ["ignore","pipe","pipe"], full inherit cascades the parent stdin=ignore
+  // to grand-child node --test, breaking ConPTY assumptions on Windows and
+  // surfacing as EXIT=1 (false-failed). Pipe stdin only — stdout/stderr stay
+  // inherited so the grand-child still streams to whoever attached to us.
+  const child = spawn(process.execPath, args, {
+    stdio: ["pipe", "inherit", "inherit"],
+    env: { ...process.env, TEST_LOCK_PID: String(process.pid) },
+  });
+  // Close stdin immediately so node --test never blocks waiting for input.
+  child.stdin?.end();
+
+  child.on("exit", (code) => {
+    releaseLock();
+    process.exit(code ?? 1);
+  });
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === SCRIPT_PATH) {
+  main();
+}