@triflux/core 10.31.0 → 10.33.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/core",
-  "version": "10.31.0",
+  "version": "10.33.0",
   "description": "triflux core — CLI routing, pipeline, adapters. Zero native dependencies.",
   "type": "module",
   "main": "hub/index.mjs",

package/scripts/lib/env-probe.mjs

@@ -4,6 +4,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveHubPortForContext } from "../../hub/hub-lifecycle.mjs";
 import { whichCommand, whichCommandAsync } from "../../hub/platform.mjs";
 
 const HUB_DEFAULT_PORT = 27888;
@@ -37,13 +38,36 @@ function fetchHubStatus({
   };
 }
 
-export function resolveDefaultStatusUrl(env = process.env) {
-  const envPort = Number.parseInt(String(env?.TFX_HUB_PORT ?? ""), 10);
-  const port =
-    Number.isFinite(envPort) && envPort > 0 ? envPort : HUB_DEFAULT_PORT;
+export function resolveDefaultStatusUrl(env = process.env, cwd = process.cwd()) {
+  const port = resolveHubPortForContext({
+    env,
+    cwd,
+    defaultPort: HUB_DEFAULT_PORT,
+  });
   return `http://127.0.0.1:${port}/status`;
 }
 
+function resolveStatusUrlForContext({
+  statusUrl,
+  env = process.env,
+  cwd = process.cwd(),
+} = {}) {
+  try {
+    const url = new URL(String(statusUrl));
+    url.port = String(
+      resolveHubPortForContext({
+        port: url.port,
+        env,
+        cwd,
+        defaultPort: HUB_DEFAULT_PORT,
+      }),
+    );
+    return url.toString();
+  } catch {
+    return resolveDefaultStatusUrl(env, cwd);
+  }
+}
+
 function normalizeCliName(name) {
   return String(name ?? "").trim() || null;
 }
@@ -212,8 +236,10 @@ export function detectCodexPlan(options = {}) {
 }
 
 export function checkHub({
+  env = process.env,
+  cwd = process.cwd(),
   pkgRoot = DEFAULT_PKG_ROOT,
-  statusUrl = resolveDefaultStatusUrl(),
+  statusUrl = resolveDefaultStatusUrl(env, cwd),
   restart = true,
   requestTimeoutMs = 3000,
   pollAttempts = 8,
@@ -223,10 +249,11 @@ export function checkHub({
   existsSyncFn = existsSync,
   sleepSyncFn = sleepSync,
 } = {}) {
+  const guardedStatusUrl = resolveStatusUrlForContext({ statusUrl, env, cwd });
   try {
     return fetchHubStatus({
       execSyncFn,
-      statusUrl,
+      statusUrl: guardedStatusUrl,
       timeout: requestTimeoutMs,
     });
   } catch {}
@@ -239,7 +266,7 @@ export function checkHub({
 
   try {
     const child = spawnFn(process.execPath, [serverPath], {
-      env: { ...process.env, TFX_HUB_PORT: String(new URL(statusUrl).port) },
+      env: { ...env, TFX_HUB_PORT: String(new URL(guardedStatusUrl).port) },
       detached: true,
       stdio: "ignore",
       windowsHide: true,
@@ -254,7 +281,7 @@ export function checkHub({
     try {
       const status = fetchHubStatus({
         execSyncFn,
-        statusUrl,
+        statusUrl: guardedStatusUrl,
         timeout: Math.min(requestTimeoutMs, 1000),
       });
       if (status.state === "healthy") {