triflux 10.31.0 → 10.32.0

package/hooks/codex-session-hook.mjs

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+
+import { argv, exit, stdin, stdout } from "node:process";
+import { pathToFileURL } from "node:url";
+import { drainPendingSynapse as defaultDrainPendingSynapse } from "../hub/team/synapse-http.mjs";
+import {
+  heartbeatInteractiveSession as defaultHeartbeatInteractiveSession,
+  registerInteractiveSession as defaultRegisterInteractiveSession,
+} from "./session-start-fast.mjs";
+
+// hub-ensure is loaded lazily so the byte-identical packages/core mirror of this
+// file loads cleanly. packages/core mirrors scripts/lib only (not scripts/*), so a
+// static `../scripts/hub-ensure.mjs` import would make the core copy throw
+// ERR_MODULE_NOT_FOUND at load time. The core copy is published-but-dormant — the
+// live codex hook always runs from the installed triflux package where the path
+// resolves. This mirrors session-start-fast.mjs's dynamic script-import pattern.
+async function defaultHubEnsureRun(stdinData) {
+  const { run } = await import(
+    new URL("../scripts/hub-ensure.mjs", import.meta.url).href
+  );
+  return run(stdinData);
+}
+
+function parsePayload(stdinData) {
+  try {
+    const raw = typeof stdinData === "string" ? stdinData : "";
+    return raw.trim()
+      ? { ok: true, payload: JSON.parse(raw) }
+      : { ok: false, payload: {} };
+  } catch {
+    return { ok: false, payload: {} };
+  }
+}
+
+function normalizeMode(mode, payload) {
+  const direct = String(mode || "")
+    .trim()
+    .toLowerCase();
+  if (direct === "register" || direct === "heartbeat") return direct;
+
+  const eventName = String(payload?.hook_event_name || "")
+    .trim()
+    .toLowerCase()
+    .replace(/-/g, "_");
+  if (eventName === "session_start" || eventName === "sessionstart") {
+    return "register";
+  }
+  if (eventName === "user_prompt_submit" || eventName === "userpromptsubmit") {
+    return "heartbeat";
+  }
+  return "";
+}
+
+export async function runCodexSessionHook(stdinData, opts = {}) {
+  const output = "{}\n";
+  const parsed = parsePayload(stdinData);
+  const mode = parsed.ok
+    ? normalizeMode(opts.argvMode ?? argv[2], parsed.payload)
+    : "";
+  const hubEnsureRun = opts.hubEnsureRun || defaultHubEnsureRun;
+  const registerInteractiveSession =
+    opts.registerInteractiveSession || defaultRegisterInteractiveSession;
+  const heartbeatInteractiveSession =
+    opts.heartbeatInteractiveSession || defaultHeartbeatInteractiveSession;
+  const drainPendingSynapse =
+    opts.drainPendingSynapse || defaultDrainPendingSynapse;
+
+  try {
+    if (mode === "register") {
+      try {
+        await hubEnsureRun(stdinData);
+      } catch {}
+      try {
+        registerInteractiveSession(stdinData);
+      } catch {}
+      try {
+        await drainPendingSynapse(1000);
+      } catch {}
+    } else if (mode === "heartbeat") {
+      try {
+        heartbeatInteractiveSession(stdinData);
+      } catch {}
+      try {
+        await drainPendingSynapse(500);
+      } catch {}
+    }
+  } catch {
+    // Codex session hooks are observational and must never block the session.
+  }
+
+  if (opts.writeStdout !== false) {
+    stdout.write(output);
+  }
+  return output;
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    stdin.setEncoding("utf8");
+    stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    stdin.on("end", () => resolve(data));
+    stdin.on("error", () => resolve(data));
+  });
+}
+
+if (argv[1] && import.meta.url === pathToFileURL(argv[1]).href) {
+  const stdinData = await readStdin();
+  await runCodexSessionHook(stdinData);
+  exit(0);
+}

package/hub/server.mjs

@@ -22,6 +22,7 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
+import { runCollect } from "../cto/collect.mjs";
 import { createModuleLogger } from "../scripts/lib/logger.mjs";
 import { broker as brokerInstance, reloadBroker } from "./account-broker.mjs";
 import { createAdaptiveEngine } from "./adaptive.mjs";
@@ -53,6 +54,7 @@ import {
   writeState,
 } from "./state.mjs";
 import { createStoreAdapter } from "./store-adapter.mjs";
+import { createCtoAutoCollector } from "./team/cto-auto-collect.mjs";
 import { createGitPreflight } from "./team/git-preflight.mjs";
 import { nativeProxy } from "./team/nativeProxy.mjs";
 import { createSwarmLocks } from "./team/swarm-locks.mjs";
@@ -1009,10 +1011,16 @@ export async function startHub({
     registry: synapseRegistry,
     locks: swarmLocks,
   });
+  const ctoAutoCollector = createCtoAutoCollector({
+    registry: synapseRegistry,
+    runCollect,
+    logger: hubLog,
+  });
 
   // Synapse Layer 5: emitter subscribers — bridge events to hub logging
-  synapseEmitter.on("synapse.session.started", ({ sessionId }) => {
+  synapseEmitter.on("synapse.session.started", ({ sessionId, session }) => {
     hubLog.info({ sessionId }, "synapse.session.started");
+    ctoAutoCollector.handleSessionStarted({ sessionId, session });
   });
   synapseEmitter.on("synapse.session.heartbeat", ({ sessionId }) => {
     hubLog.debug({ sessionId }, "synapse.session.heartbeat");

package/hub/team/cto-auto-collect.mjs

@@ -0,0 +1,109 @@
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+const DEFAULT_DEBOUNCE_MS = 120_000;
+const OFF_VALUES = new Set(["0", "false", "off", "no"]);
+
+export function isCtoAutoCollectDisabled(env = process.env) {
+  return OFF_VALUES.has(
+    String(env?.TFX_CTO_AUTO_COLLECT ?? "")
+      .trim()
+      .toLowerCase(),
+  );
+}
+
+function freshCurrentMd(projectRoot, now, debounceMs) {
+  try {
+    const currentMd = join(projectRoot, ".triflux", "lake", "current.md");
+    if (!existsSync(currentMd)) return false;
+    return now - statSync(currentMd).mtimeMs < debounceMs;
+  } catch {
+    return false;
+  }
+}
+
+export function createCtoAutoCollector(opts = {}) {
+  const registry = opts.registry;
+  const runCollect = opts.runCollect;
+  const logger = opts.logger || null;
+  const debounceMs = Number(opts.debounceMs || DEFAULT_DEBOUNCE_MS);
+  const now = opts.now || (() => Date.now());
+  const env = opts.env || process.env;
+  const lastCollectMs = opts.lastCollectMs || new Map();
+  const inFlight = new Set();
+
+  function handleSessionStarted({ sessionId, session } = {}) {
+    if (isCtoAutoCollectDisabled(env))
+      return { triggered: false, reason: "disabled" };
+    if (!registry || typeof registry.querySessions !== "function") {
+      return { triggered: false, reason: "missing-registry" };
+    }
+    if (typeof runCollect !== "function") {
+      return { triggered: false, reason: "missing-runCollect" };
+    }
+
+    const cwd = typeof session?.cwd === "string" ? session.cwd : "";
+    const worktree =
+      typeof session?.worktreePath === "string" ? session.worktreePath : "";
+    const projectRoot = worktree || cwd;
+    if (!projectRoot)
+      return { triggered: false, reason: "missing-project-root" };
+
+    let peers = [];
+    try {
+      peers = registry.querySessions({
+        cwd,
+        worktree,
+        excludeSessionId: sessionId,
+      });
+    } catch (error) {
+      logger?.warn?.(
+        { sessionId, err: String(error?.message || error) },
+        "cto.auto_collect.query_failed",
+      );
+      return { triggered: false, reason: "query-failed" };
+    }
+    if (!Array.isArray(peers) || peers.length < 1) {
+      return { triggered: false, reason: "no-peers" };
+    }
+
+    const currentTime = now();
+    const last = lastCollectMs.get(projectRoot) || 0;
+    if (currentTime - last < debounceMs) {
+      return { triggered: false, reason: "debounced" };
+    }
+    if (freshCurrentMd(projectRoot, currentTime, debounceMs)) {
+      lastCollectMs.set(projectRoot, currentTime);
+      return { triggered: false, reason: "fresh-lake" };
+    }
+
+    lastCollectMs.set(projectRoot, currentTime);
+    const promise = Promise.resolve()
+      .then(() => runCollect([], { rootDir: projectRoot }))
+      .catch((error) => {
+        logger?.warn?.(
+          { projectRoot, err: String(error?.message || error) },
+          "cto.auto_collect.failed",
+        );
+      })
+      .finally(() => {
+        inFlight.delete(promise);
+      });
+    inFlight.add(promise);
+    return {
+      triggered: true,
+      reason: "triggered",
+      projectRoot,
+      peerCount: peers.length,
+    };
+  }
+
+  async function drain() {
+    await Promise.allSettled([...inFlight]);
+  }
+
+  return Object.freeze({
+    handleSessionStarted,
+    drain,
+  });
+}

package/package.json

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

package/scripts/ensure-codex-hooks.mjs

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = dirname(__dirname);
+const SESSION_START_MATCHER = "startup|resume|clear";
+const TRIFLUX_HOOK_BASENAME = "codex-session-hook.mjs";
+
+function atomicWriteFile(path, content) {
+  const tmpPath = `${path}.tmp-${process.pid}-${Date.now()}`;
+  writeFileSync(tmpPath, content, "utf8");
+  renameSync(tmpPath, path);
+}
+
+function quoteCommandPath(value) {
+  return `"${String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function buildCommand(nodeBin, hookScriptPath, mode) {
+  return `${nodeBin} ${quoteCommandPath(hookScriptPath)} ${mode}`;
+}
+
+export function canonicalJson(value) {
+  if (Array.isArray(value)) return value.map((item) => canonicalJson(item));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.keys(value)
+        .sort()
+        .map((key) => [key, canonicalJson(value[key])]),
+    );
+  }
+  return value;
+}
+
+export function computeTrustedHookHash({
+  eventName,
+  matcher,
+  command,
+  timeout,
+  statusMessage,
+}) {
+  const hook = {
+    type: "command",
+    command,
+    timeout: Math.max(1, Number(timeout ?? 600)),
+    async: false,
+  };
+  if (statusMessage) hook.statusMessage = statusMessage;
+  const identity = {
+    event_name: eventName,
+    ...(matcher ? { matcher } : {}),
+    hooks: [hook],
+  };
+  return `sha256:${createHash("sha256")
+    .update(JSON.stringify(canonicalJson(identity)))
+    .digest("hex")}`;
+}
+
+function normalizeHooksJson(raw) {
+  try {
+    const parsed = raw.trim() ? JSON.parse(raw) : {};
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { hooks: {} };
+    }
+    if (!parsed.hooks || typeof parsed.hooks !== "object") parsed.hooks = {};
+    return parsed;
+  } catch {
+    return { hooks: {} };
+  }
+}
+
+function isTrifluxHookGroup(group) {
+  return Array.isArray(group?.hooks)
+    ? group.hooks.some(
+        (hook) =>
+          typeof hook?.command === "string" &&
+          hook.command.includes(TRIFLUX_HOOK_BASENAME),
+      )
+    : false;
+}
+
+function upsertHookGroup(groups, desired) {
+  const list = Array.isArray(groups) ? [...groups] : [];
+  const existingIndex = list.findIndex((group) => isTrifluxHookGroup(group));
+  if (existingIndex >= 0) {
+    list[existingIndex] = desired;
+    return { groups: list, index: existingIndex };
+  }
+  list.push(desired);
+  return { groups: list, index: list.length - 1 };
+}
+
+function buildDesiredGroups({ nodeBin, hookScriptPath }) {
+  return {
+    SessionStart: {
+      matcher: SESSION_START_MATCHER,
+      hooks: [
+        {
+          type: "command",
+          command: buildCommand(nodeBin, hookScriptPath, "register"),
+          timeout: 15,
+        },
+      ],
+    },
+    UserPromptSubmit: {
+      hooks: [
+        {
+          type: "command",
+          command: buildCommand(nodeBin, hookScriptPath, "heartbeat"),
+          timeout: 10,
+        },
+      ],
+    },
+  };
+}
+
+function formatHooksJson(value) {
+  return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+function escapeTomlKey(key) {
+  return `"${String(key).replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function stateLine(key, hash) {
+  return `${escapeTomlKey(key)} = { trusted_hash = "${hash}" }`;
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function stripManagedStateLines(content, managedKeys, hooksPath) {
+  if (!content) return "";
+  const escapedKeys = [...managedKeys].map((key) =>
+    escapeRegExp(escapeTomlKey(key)),
+  );
+  for (const label of ["session_start", "user_prompt_submit"]) {
+    escapedKeys.push(
+      escapeRegExp(escapeTomlKey(`${hooksPath}:${label}:`)).replace(
+        /"$/,
+        '\\d+:\\d+"',
+      ),
+    );
+  }
+  const re = new RegExp(
+    `^\\s*(?:${escapedKeys.join("|")})\\s*=\\s*\\{\\s*trusted_hash\\s*=.*\\}\\s*$`,
+    "gm",
+  );
+  return content.replace(re, "").replace(/\n{3,}/g, "\n\n");
+}
+
+function mergeHooksState(content, entries, hooksPath) {
+  const managedKeys = new Set(entries.map((entry) => entry.key));
+  let updated = stripManagedStateLines(content, managedKeys, hooksPath);
+  const lines = entries.map((entry) => stateLine(entry.key, entry.hash));
+  const sectionRe = /^\[hooks\.state\]\s*$/m;
+  const match = sectionRe.exec(updated);
+
+  if (!match) {
+    if (updated.length > 0 && !updated.endsWith("\n")) updated += "\n";
+    if (updated.length > 0 && !updated.endsWith("\n\n")) updated += "\n";
+    return `${updated}[hooks.state]\n${lines.join("\n")}\n`;
+  }
+
+  const sectionStart = match.index;
+  const afterHeader = match.index + match[0].length;
+  const nextSectionMatch = /^\[[^\]]+\]\s*$/m.exec(updated.slice(afterHeader));
+  const sectionEnd = nextSectionMatch
+    ? afterHeader + nextSectionMatch.index
+    : updated.length;
+  let sectionBody = updated.slice(sectionStart, sectionEnd).trimEnd();
+  sectionBody += `\n${lines.join("\n")}\n`;
+  return (
+    updated.slice(0, sectionStart) + sectionBody + updated.slice(sectionEnd)
+  );
+}
+
+function timestamp() {
+  return new Date()
+    .toISOString()
+    .replace(/[-:.TZ]/g, "")
+    .slice(0, 14);
+}
+
+export function ensureCodexHooks(opts = {}) {
+  const codexHome = opts.codexHome || join(homedir(), ".codex");
+  if (!existsSync(codexHome)) {
+    return { skipped: true, changedHooks: false, changedConfig: false };
+  }
+
+  const hooksPath = resolve(codexHome, "hooks.json");
+  const configPath = resolve(codexHome, "config.toml");
+  const hookScriptPath = resolve(
+    opts.hookScriptPath || join(PROJECT_ROOT, "hooks", TRIFLUX_HOOK_BASENAME),
+  );
+  const nodeBin = opts.nodeBin || process.execPath;
+  const desired = buildDesiredGroups({ nodeBin, hookScriptPath });
+
+  const hooksJson = normalizeHooksJson(
+    existsSync(hooksPath) ? readFileSync(hooksPath, "utf8") : "",
+  );
+  const sessionStart = upsertHookGroup(
+    hooksJson.hooks.SessionStart,
+    desired.SessionStart,
+  );
+  const promptSubmit = upsertHookGroup(
+    hooksJson.hooks.UserPromptSubmit,
+    desired.UserPromptSubmit,
+  );
+  hooksJson.hooks.SessionStart = sessionStart.groups;
+  hooksJson.hooks.UserPromptSubmit = promptSubmit.groups;
+
+  const originalHooks = existsSync(hooksPath)
+    ? readFileSync(hooksPath, "utf8")
+    : "";
+  const nextHooks = formatHooksJson(hooksJson);
+  const changedHooks = originalHooks !== nextHooks;
+  if (changedHooks) {
+    mkdirSync(dirname(hooksPath), { recursive: true });
+    atomicWriteFile(hooksPath, nextHooks);
+  }
+
+  const stateEntries = [
+    {
+      key: `${hooksPath}:session_start:${sessionStart.index}:0`,
+      hash: computeTrustedHookHash({
+        eventName: "session_start",
+        matcher: desired.SessionStart.matcher,
+        command: desired.SessionStart.hooks[0].command,
+        timeout: desired.SessionStart.hooks[0].timeout,
+      }),
+    },
+    {
+      key: `${hooksPath}:user_prompt_submit:${promptSubmit.index}:0`,
+      hash: computeTrustedHookHash({
+        eventName: "user_prompt_submit",
+        command: desired.UserPromptSubmit.hooks[0].command,
+        timeout: desired.UserPromptSubmit.hooks[0].timeout,
+      }),
+    },
+  ];
+
+  const originalConfig = existsSync(configPath)
+    ? readFileSync(configPath, "utf8")
+    : "";
+  const nextConfig = mergeHooksState(originalConfig, stateEntries, hooksPath);
+  const changedConfig = originalConfig !== nextConfig;
+  if (changedConfig) {
+    if (existsSync(configPath)) {
+      const backupPath = `${configPath}.bak-tfx-codex-hooks-${opts.backupTimestamp || timestamp()}`;
+      if (!existsSync(backupPath)) {
+        writeFileSync(backupPath, originalConfig, "utf8");
+      }
+    }
+    atomicWriteFile(configPath, nextConfig);
+  }
+
+  return {
+    skipped: false,
+    changedHooks,
+    changedConfig,
+    hooksPath,
+    configPath,
+  };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const result = ensureCodexHooks();
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+}

package/scripts/setup.mjs

@@ -26,6 +26,7 @@ import {
   ensureTfxSection,
   getLatestRoutingTable,
 } from "./claudemd-sync.mjs";
+import { ensureCodexHooks } from "./ensure-codex-hooks.mjs";
 import { addPluginRootFallbackToCommand } from "./lib/doctor-env-checks.mjs";
 import { cleanupTmpFiles } from "./tmp-cleanup.mjs";
 
@@ -1373,6 +1374,9 @@ function ensureCriticalSetup() {
   try {
     ensureCodexProfiles();
   } catch {}
+  try {
+    ensureCodexHooks();
+  } catch {}
 }
 
 export {
@@ -1383,6 +1387,7 @@ export {
   cleanupStaleSkills,
   DEPRECATED_SKILLS,
   detectDevMode,
+  ensureCodexHooks,
   ensureCodexHubServerConfig,
   ensureCodexProfiles,
   ensureHooksInSettings,
@@ -2147,6 +2152,21 @@ export async function runDeferred(stdinData) {
     synced++;
   }
 
+  try {
+    const codexHooksResult = ensureCodexHooks();
+    if (
+      !codexHooksResult?.skipped &&
+      (codexHooksResult?.changedHooks || codexHooksResult?.changedConfig)
+    ) {
+      io.log("  \x1b[32m✓\x1b[0m Codex hooks: registered session sync hooks");
+      synced++;
+    }
+  } catch (error) {
+    io.log(
+      `  \x1b[33m⚠\x1b[0m Codex hooks 등록 실패: ${error.message || error}`,
+    );
+  }
+
   // ── Windows Codex 단독 실행 보호: 로그인 시 hub-ensure 등록 ──
   // Claude SessionStart 훅이 없는 순수 Codex 시작 경로에서도 tfx-hub가 살아있게 한다.
   if (enableHubAutostart) {