@triflux/core 10.42.0 → 10.44.0

package/hub/team/synapse-http.mjs

@@ -1,6 +1,9 @@
-import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { dirname, join } from "node:path";
+import { normalizeRoleKey } from "../role-contract.mjs";
 
 const HUB_DEFAULT_PORT = 27888;
 // Same token file as hub/bridge.mjs (HUB_TOKEN_FILE). Kept inline rather than
@@ -21,6 +24,144 @@ function normalizeToken(raw) {
   return token || null;
 }
 
+function opaqueId(prefix, value) {
+  return `${prefix}_${createHash("sha256")
+    .update(String(value || ""))
+    .digest("base64url")
+    .slice(0, 22)}`;
+}
+
+function normalizedProjectId(value) {
+  try {
+    return normalizeRoleKey({ project_id: value, role_kind: "cto" }).project_id;
+  } catch {
+    return "";
+  }
+}
+
+function resolveProjectId(cwd, meta, opts = {}) {
+  const explicit = meta?.project_id || process.env.TFX_PROJECT_ID;
+  if (explicit) return normalizedProjectId(explicit);
+  if (typeof opts.resolveProjectId === "function") {
+    return normalizedProjectId(opts.resolveProjectId(cwd));
+  }
+  let current = cwd;
+  while (current) {
+    const manifest = join(current, ".triflux", "project.json");
+    if (existsSync(manifest)) {
+      try {
+        const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+        if (parsed?.schema_version !== "tfx.project.v1") return "";
+        return normalizedProjectId(parsed.project_id);
+      } catch {
+        return "";
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return "";
+}
+
+function inferSessionCli(meta, opts = {}) {
+  const explicit = String(meta?.cli || meta?.actor_cli || "")
+    .trim()
+    .toLowerCase();
+  if (explicit === "codex" || explicit === "claude") return explicit;
+  const entrypoint = String(opts.entrypoint ?? process.argv[1] ?? "");
+  if (entrypoint.includes("codex-session-hook")) return "codex";
+  if (entrypoint.includes("agy-session-hook")) return "other";
+  return "claude";
+}
+
+function resolveTmuxSession(meta, opts = {}) {
+  const explicit =
+    meta?.tmux_session || meta?.session_name || process.env.TFX_TMUX_SESSION;
+  if (explicit) return String(explicit).trim();
+  if (!process.env.TMUX) return "";
+  try {
+    const run =
+      opts.tmuxSessionName ||
+      (() =>
+        execFileSync("tmux", ["display-message", "-p", "#{session_name}"], {
+          encoding: "utf8",
+          timeout: 200,
+          windowsHide: true,
+        }));
+    return String(run() || "").trim();
+  } catch {
+    return "";
+  }
+}
+
+export function buildSynapseRegistrationMeta(meta, opts = {}) {
+  if (!meta || meta.sessionKind !== "interactive") return meta;
+  const sessionId = String(meta.sessionId || "").trim();
+  if (!sessionId) return meta;
+  const cwd = typeof meta.cwd === "string" ? meta.cwd : process.cwd();
+  const cli = inferSessionCli(meta, opts);
+  const hostId = String(
+    meta.host_id ||
+      process.env.TFX_HOST_ID ||
+      opaqueId("hst", opts.hostname?.() || hostname()),
+  ).trim();
+  const expiresAtMs = Number(opts.nowMs?.() ?? Date.now()) + 299000;
+  const transportLocators = [];
+  if (cli === "claude") {
+    transportLocators.push({
+      schema_version: "tfx.transport-locator.v1",
+      transport_id: opaqueId("trn", `claude-uds:${hostId}:${sessionId}`),
+      kind: "claude-uds",
+      host_id: hostId,
+      capabilities: ["probe", "wake", "activate", "interrupt"],
+      priority: 100,
+      expires_at_ms: expiresAtMs,
+      locator: {
+        session_id: sessionId,
+        bridge_id: String(
+          meta.bridge_id || process.env.TFX_BRIDGE_ID || "local-hub",
+        ),
+      },
+    });
+  }
+  const tmuxSession = resolveTmuxSession(meta, opts);
+  if (tmuxSession) {
+    const muxServerSource =
+      meta.mux_server_id ||
+      process.env.TFX_MUX_SERVER_ID ||
+      String(process.env.TMUX || "default").split(",", 1)[0];
+    transportLocators.push({
+      schema_version: "tfx.transport-locator.v1",
+      transport_id: opaqueId("trn", `tmux:${hostId}:${tmuxSession}`),
+      kind: "tmux",
+      host_id: hostId,
+      capabilities: ["probe", "wake", "activate", "interrupt"],
+      priority: cli === "codex" ? 100 : 50,
+      expires_at_ms: expiresAtMs,
+      locator: {
+        session_name: tmuxSession,
+        mux_server_id: opaqueId("mux", muxServerSource),
+      },
+    });
+  }
+  const directAgentId = `session:${sessionId}`;
+  return {
+    ...meta,
+    agent_id:
+      meta.agent_id ||
+      (directAgentId.length <= 64 && /^[a-zA-Z0-9._:-]+$/u.test(directAgentId)
+        ? directAgentId
+        : opaqueId("session", sessionId)),
+    cli,
+    project_id: resolveProjectId(cwd, meta, opts) || undefined,
+    session_id: meta.session_id || sessionId,
+    host_id: hostId,
+    transport_locators_json:
+      meta.transport_locators_json ?? JSON.stringify(transportLocators),
+  };
+}
+
 // Mirrors hub/bridge.mjs:readHubToken — env override first, then the token file.
 // Missing token → null (backward-compatible with token-less hubs).
 function readHubToken() {
@@ -139,7 +280,11 @@ export function drainPendingSynapse(timeoutMs = 1000) {
 }
 
 export function registerSynapseSession(meta, opts = {}) {
-  return fireAndForgetSynapse("/synapse/register", meta, opts);
+  return fireAndForgetSynapse(
+    "/synapse/register",
+    buildSynapseRegistrationMeta(meta, opts),
+    opts,
+  );
 }
 
 export function heartbeatSynapseSession(

package/hud/constants.mjs

@@ -50,6 +50,13 @@ export const CONTEXT_MONITOR_CACHE_PATH = join(
   "tfx-hub",
   "context-monitor.json",
 );
+export const HUB_REQUEST_MONITOR_CACHE_PATH = join(
+  homedir(),
+  ".claude",
+  "cache",
+  "tfx-hub",
+  "hub-request-context-monitor.json",
+);
 export const CONTEXT_MONITOR_LEGACY_PATH = join(
   homedir(),
   ".omc",
@@ -122,6 +129,20 @@ export const ONE_DAY_MS = 24 * 60 * 60 * 1000;
 export const DEFAULT_OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
 
 export const CODEX_AUTH_PATH = join(homedir(), ".codex", "auth.json");
+export const CODEX_PROBE_STATE_PATH = join(
+  homedir(),
+  ".claude",
+  "cache",
+  "codex-probe-state.json",
+);
+export const CODEX_BROKER_AUTH_CACHE_DIR = join(
+  homedir(),
+  ".claude",
+  "cache",
+  "tfx-hub",
+);
+export const CODEX_PROBE_TTL_MS = 5 * 60 * 1000;
+export const CODEX_PROBE_TIMEOUT_MS = 10_000;
 export const CODEX_QUOTA_CACHE_PATH = join(
   homedir(),
   ".claude",

package/hud/context-monitor.mjs

@@ -283,26 +283,23 @@ export function deriveContextLimit(stdin) {
 
 export function buildContextUsageView(stdin, snapshot = null) {
   const stdinUsage = getStdinContextUsage(stdin);
-  const monitor = snapshot || readContextMonitorSnapshot();
-  const modelId = stdin?.model?.id ?? stdin?.model;
-  const modelHintLimit = resolveModelLimit(modelId);
-  const monitorLimit = Number(monitor?.limitTokens || 0);
-  const stdinLimit = stdinUsage?.limitTokens;
-  // When a model id is known it is the authoritative per-model ceiling: the
-  // monitor's cached limitTokens is just a default-derived accumulator (now 1M
-  // by default) and must not override a known model's real window in either
-  // direction — it would inflate a 200K model (Sonnet 4.5 / Haiku) up to 1M.
-  // The model hint already upgrades a stale-low monitor on its own (#88).
-  const limitTokens =
-    stdinLimit != null && stdinLimit > 0
-      ? Math.max(1, stdinLimit)
-      : modelId
-        ? Math.max(1, modelHintLimit)
-        : Math.max(1, monitorLimit || modelHintLimit);
+  if (!stdinUsage) {
+    return {
+      usedTokens: 0,
+      limitTokens: 0,
+      percent: 0,
+      display: "--",
+      warningLevel: "ok",
+      warningMessage: "",
+      warningTag: "",
+      source: "none",
+    };
+  }
 
-  const usedTokens = stdinUsage?.usedTokens ?? Number(monitor?.usedTokens || 0);
-  const percent =
-    limitTokens > 0 ? clampPercent((usedTokens / limitTokens) * 100) : 0;
+  const modelId = stdin?.model?.id ?? stdin?.model;
+  const limitTokens = Math.max(1, stdinUsage.limitTokens);
+  const usedTokens = stdinUsage.usedTokens;
+  const percent = clampPercent((usedTokens / limitTokens) * 100);
 
   const warning = classifyContextThreshold(percent);
   const showInfoOnlyStatus = !(
@@ -324,12 +321,12 @@ export function buildContextUsageView(stdin, snapshot = null) {
           : warning.level === "info"
             ? "ℹ 절반 이상 사용"
             : "",
-    source: stdinUsage?.source || (monitor ? "monitor" : "none"),
+    source: stdinUsage.source,
   };
 }
 
 export function createContextMonitor(options = {}) {
-  // Default to a 1M context window (Opus 4.x [1M] / Codex gpt-5.5 both run on
+  // Default to a 1M context window (Opus 4.x [1M] / Codex GPT-5.6 family runs on
   // a 1M window) when no explicit limit is supplied, so the cached percent the
   // Stop hook reads is not inflated against a 200K assumption — assuming 200K
   // there false-positives at ~15% real usage and blocks legitimate stops.

package/hud/hud-qos-status.mjs

@@ -97,7 +97,7 @@ async function main() {
   }
 
   if (process.argv.includes(CODEX_REFRESH_FLAG)) {
-    refreshCodexRateLimitsCache();
+    await refreshCodexRateLimitsCache();
     return;
   }
 

package/hud/providers/codex-probe.mjs

@@ -0,0 +1,216 @@
+// codex app-server account/rateLimits/read 능동 프로브 + 정규화.
+// 세션 이벤트(snake_case) 파이프라인에 합류 가능한 스냅샷을 만든다.
+
+import { spawn } from "node:child_process";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+function readJwtExpSec(token) {
+  try {
+    const payload = JSON.parse(
+      Buffer.from(token.split(".")[1], "base64url").toString("utf-8"),
+    );
+    return Number(payload.exp) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+function readJsonFile(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+const EXP_MARGIN_SEC = 600;
+
+function accessTokenUsable(auth, nowMs) {
+  const token = auth?.tokens?.access_token;
+  if (!token) return false;
+  const exp = readJwtExpSec(token);
+  return exp > Math.floor(nowMs / 1000) + EXP_MARGIN_SEC;
+}
+
+export function recordProbe(stateFilePath, key, nowMs) {
+  const state = readJsonFile(stateFilePath) || {};
+  state[key] = nowMs;
+  try {
+    mkdirSync(dirname(stateFilePath), { recursive: true });
+    writeFileSync(stateFilePath, JSON.stringify(state));
+  } catch {
+    // 상태 기록 실패는 무시 — 다음 사이클에 재시도
+  }
+}
+
+export function listProbeTargets({
+  codexAuthPath,
+  brokerCacheDir,
+  stateFilePath,
+  ttlMs,
+  nowMs,
+}) {
+  const state = readJsonFile(stateFilePath) || {};
+  const due = (key) =>
+    !(Number(state[key]) > 0 && nowMs - Number(state[key]) < ttlMs);
+  const targets = [];
+
+  const currentAuth = readJsonFile(codexAuthPath);
+  if (currentAuth && accessTokenUsable(currentAuth, nowMs) && due("current")) {
+    targets.push({ key: "current", codexHome: dirname(codexAuthPath) });
+  }
+
+  if (brokerCacheDir && existsSync(brokerCacheDir)) {
+    let files = [];
+    try {
+      files = readdirSync(brokerCacheDir).filter((file) =>
+        /^codex-auth-.+\.json$/.test(file),
+      );
+    } catch {
+      files = [];
+    }
+    for (const file of files) {
+      const key = file.replace(/^codex-auth-/, "").replace(/\.json$/, "");
+      if (!due(key)) continue;
+      const auth = readJsonFile(join(brokerCacheDir, file));
+      if (!auth || !accessTokenUsable(auth, nowMs)) continue;
+      const home = mkdtempSync(join(tmpdir(), `tfx-probe-home-${key}-`));
+      writeFileSync(join(home, "auth.json"), JSON.stringify(auth));
+      targets.push({ key, codexHome: home });
+    }
+  }
+  return targets;
+}
+
+function toSnakeBucket(bucket) {
+  if (!bucket) return null;
+  return {
+    used_percent: bucket.usedPercent ?? null,
+    window_minutes: bucket.windowDurationMins ?? null,
+    resets_at: bucket.resetsAt ?? null,
+  };
+}
+
+function toSnapshot(entry, nowIso) {
+  return {
+    limitId: entry.limitId,
+    limitName: entry.limitName ?? null,
+    primary: toSnakeBucket(entry.primary),
+    secondary: toSnakeBucket(entry.secondary),
+    credits: entry.credits ?? null,
+    tokens: null,
+    contextWindow: null,
+    timestamp: nowIso,
+    probe: true,
+  };
+}
+
+export function normalizeAppServerRateLimits(result, nowIso) {
+  if (!result) return [];
+  const byId = result.rateLimitsByLimitId;
+  if (byId && typeof byId === "object" && Object.keys(byId).length > 0) {
+    return Object.values(byId)
+      .filter((e) => e?.limitId)
+      .map((e) => toSnapshot(e, nowIso));
+  }
+  if (result.rateLimits?.limitId) {
+    return [toSnapshot(result.rateLimits, nowIso)];
+  }
+  return [];
+}
+
+export function probeRateLimitsViaAppServer({
+  codexHome = null,
+  spawnBin = "codex",
+  spawnArgs = ["app-server"],
+  timeoutMs = 10000,
+  now = new Date(),
+} = {}) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(spawnBin, spawnArgs, {
+        stdio: ["pipe", "pipe", "ignore"],
+        env: codexHome
+          ? { ...process.env, CODEX_HOME: codexHome }
+          : process.env,
+      });
+    } catch {
+      resolve(null);
+      return;
+    }
+    let settled = false;
+    let buf = "";
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        child.kill();
+      } catch {
+        // 이미 종료
+      }
+      resolve(value);
+    };
+    const timer = setTimeout(() => finish(null), timeoutMs);
+    const send = (obj) => {
+      try {
+        child.stdin.write(`${JSON.stringify(obj)}\n`);
+      } catch {
+        finish(null);
+      }
+    };
+    child.on("error", () => finish(null));
+    child.on("exit", () => finish(null));
+    child.stdout.on("data", (data) => {
+      buf += data.toString();
+      let idx = buf.indexOf("\n");
+      while (idx >= 0) {
+        const line = buf.slice(0, idx);
+        buf = buf.slice(idx + 1);
+        idx = buf.indexOf("\n");
+        if (!line.trim()) continue;
+        let msg;
+        try {
+          msg = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (msg.id === 1 && msg.result) {
+          send({
+            jsonrpc: "2.0",
+            id: 2,
+            method: "account/rateLimits/read",
+            params: {},
+          });
+        } else if (msg.id === 2) {
+          if (msg.error) finish(null);
+          else {
+            finish(normalizeAppServerRateLimits(msg.result, now.toISOString()));
+          }
+        }
+      }
+    });
+    send({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: {
+        clientInfo: {
+          name: "triflux-hud-probe",
+          title: "triflux HUD quota probe",
+          version: "1.0.0",
+        },
+      },
+    });
+  });
+}