triflux 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/hub/hub-lifecycle.mjs

@@ -0,0 +1,242 @@
+// hub/hub-lifecycle.mjs — Hub process lifecycle helpers
+
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const HUB_DEFAULT_PORT = 27888;
+
+const HUB_PID_FILE = join(homedir(), ".claude", "cache", "tfx-hub", "hub.pid");
+const EPHEMERAL_ENV_KEYS = [
+  "TFX_WORKER_SANDBOX_SCOPE",
+  "TFX_WORKER_INDEX",
+  "TFX_TEAM_TASK_ID",
+  "TFX_TEAM_AGENT_NAME",
+  "TFX_EPHEMERAL",
+];
+
+function parsePositiveInt(value) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
+function parsePortFromUrl(value) {
+  try {
+    return parsePositiveInt(new URL(String(value)).port);
+  } catch {
+    return null;
+  }
+}
+
+export function isHubServerCommand(command) {
+  return /(^|[\\/,\s])hub[\\/]server\.mjs(?=$|[\s"'`])/i.test(
+    String(command || ""),
+  );
+}
+
+export function isWorktreeOrEphemeralHubContext({
+  cwd = process.cwd(),
+  env = process.env,
+} = {}) {
+  const normalizedCwd = String(cwd || "").replace(/\\/g, "/");
+  if (
+    normalizedCwd.includes("/.claude/worktrees/") ||
+    normalizedCwd.includes("/.worktrees/") ||
+    normalizedCwd.includes("/.codex-swarm/wt-") ||
+    /(^|\/)wt-[^/]+(?:\/|$)/u.test(normalizedCwd)
+  ) {
+    return true;
+  }
+  return EPHEMERAL_ENV_KEYS.some((key) => String(env?.[key] || "").length > 0);
+}
+
+export function resolveHubPortForContext({
+  port,
+  env = process.env,
+  cwd = process.cwd(),
+  defaultPort = HUB_DEFAULT_PORT,
+} = {}) {
+  const envPort = parsePositiveInt(port) ?? parsePositiveInt(env?.TFX_HUB_PORT);
+  const urlPort = parsePortFromUrl(env?.TFX_HUB_URL);
+  const resolvedPort = envPort ?? urlPort ?? defaultPort;
+  if (
+    resolvedPort !== defaultPort &&
+    isWorktreeOrEphemeralHubContext({ cwd, env })
+  ) {
+    return defaultPort;
+  }
+  return resolvedPort;
+}
+
+export function collectHubProcesses(
+  psOutput = "",
+  { currentPid = process.pid } = {},
+) {
+  const ownPid = Number(currentPid);
+  return String(psOutput)
+    .split(/\r?\n/u)
+    .flatMap((line) => {
+      const match = line.match(/^\s*(\d+)\s+(\d+)\s+(.+)$/u);
+      if (!match) return [];
+      const pid = Number.parseInt(match[1], 10);
+      const ppid = Number.parseInt(match[2], 10);
+      const command = match[3].trim();
+      if (!Number.isFinite(pid) || pid === ownPid) return [];
+      if (!/\bnode(?:\s|$)|\/node(?:\s|$)/u.test(command)) return [];
+      if (!isHubServerCommand(command)) return [];
+      return [{ pid, ppid, command }];
+    });
+}
+
+function readPidFilePid({
+  pidFilePath = HUB_PID_FILE,
+  readFile = readFileSync,
+} = {}) {
+  try {
+    const info = JSON.parse(readFile(pidFilePath, "utf8"));
+    const pid = Number(info?.pid);
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function findListeningPidsForPort(
+  port = HUB_DEFAULT_PORT,
+  { execFileSyncFn = execFileSync } = {},
+) {
+  try {
+    const output = execFileSyncFn(
+      "lsof",
+      ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"],
+      {
+        encoding: "utf8",
+        timeout: 1000,
+        maxBuffer: 1024 * 1024,
+      },
+    );
+    return String(output)
+      .split(/\r?\n/u)
+      .map((line) => Number.parseInt(line.trim(), 10))
+      .filter((pid) => Number.isFinite(pid) && pid > 0);
+  } catch {
+    return [];
+  }
+}
+
+async function waitForExit(
+  pid,
+  { killFn = process.kill, graceMs = 5000, pollMs = 100 } = {},
+) {
+  const deadline = Date.now() + Math.max(0, graceMs);
+  while (Date.now() <= deadline) {
+    try {
+      killFn(pid, 0);
+    } catch {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  }
+  try {
+    killFn(pid, 0);
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+export async function reapExistingHubProcesses({
+  currentPid = process.pid,
+  pidFilePath = HUB_PID_FILE,
+  execFileSyncFn = execFileSync,
+  killFn = process.kill,
+  readPidFileFn,
+  findListeningPidsForPortFn,
+  waitForExitFn,
+  graceMs = 5000,
+  pollMs = 100,
+} = {}) {
+  let output = "";
+  try {
+    output = execFileSyncFn("ps", ["-axo", "pid,ppid,command"], {
+      encoding: "utf8",
+      timeout: 1000,
+      maxBuffer: 1024 * 1024,
+    });
+  } catch {
+    return {
+      candidates: [],
+      reaped: [],
+      preserved: {
+        currentPid: Number(currentPid),
+        pidFilePid: null,
+        defaultPortPids: [],
+      },
+    };
+  }
+
+  const current = Number(currentPid);
+  const pidFileInfo =
+    typeof readPidFileFn === "function"
+      ? readPidFileFn()
+      : { pid: readPidFilePid({ pidFilePath }) };
+  const pidFilePid = parsePositiveInt(pidFileInfo?.pid);
+  const defaultPortPids = [
+    ...new Set(
+      (typeof findListeningPidsForPortFn === "function"
+        ? findListeningPidsForPortFn(HUB_DEFAULT_PORT)
+        : findListeningPidsForPort(HUB_DEFAULT_PORT, { execFileSyncFn })
+      ).map(Number),
+    ),
+  ].filter((pid) => Number.isFinite(pid) && pid > 0);
+
+  const preservedPids = new Set(
+    [current, pidFilePid, ...defaultPortPids].filter(
+      (pid) => Number.isFinite(pid) && pid > 0,
+    ),
+  );
+  const candidates = collectHubProcesses(output, { currentPid: current });
+  const reaped = [];
+  const failed = [];
+
+  for (const processInfo of candidates) {
+    if (preservedPids.has(processInfo.pid)) continue;
+    try {
+      killFn(processInfo.pid, "SIGTERM");
+      const exited =
+        typeof waitForExitFn === "function"
+          ? await waitForExitFn(processInfo.pid, { killFn, graceMs, pollMs })
+          : await waitForExit(processInfo.pid, { killFn, graceMs, pollMs });
+      if (!exited) {
+        try {
+          killFn(processInfo.pid, "SIGKILL");
+        } catch (error) {
+          failed.push({
+            pid: processInfo.pid,
+            signal: "SIGKILL",
+            error: String(error?.message || error),
+          });
+        }
+      }
+      reaped.push(processInfo);
+    } catch (error) {
+      failed.push({
+        pid: processInfo.pid,
+        signal: "SIGTERM",
+        error: String(error?.message || error),
+      });
+    }
+  }
+
+  return {
+    candidates,
+    reaped,
+    failed,
+    preserved: {
+      currentPid: current,
+      pidFilePid,
+      defaultPortPids,
+    },
+  };
+}

package/hub/mac-focus.mjs

@@ -0,0 +1,94 @@
+import { execFile } from "node:child_process";
+
+export const FOCUS_SCRIPT_TIMEOUT_MS = 5_000;
+
+const DEFAULT_FOCUS_CANDIDATES = [
+  "iTerm2",
+  "Terminal",
+  "Codex",
+  "Claude",
+  "Antigravity",
+  "Code",
+];
+
+function normalizeAgentId(value) {
+  const id = String(value || "")
+    .trim()
+    .toLowerCase();
+  if (id === "agy" || id === "anti") return "antigravity";
+  return id;
+}
+
+export function getFocusCandidates({ agentId } = {}) {
+  switch (normalizeAgentId(agentId)) {
+    case "codex":
+      return ["Codex", "iTerm2", "Terminal", "Code"];
+    case "claude":
+      return ["Claude", "iTerm2", "Terminal"];
+    case "antigravity":
+      return ["Antigravity", "iTerm2", "Terminal"];
+    default:
+      return [...DEFAULT_FOCUS_CANDIDATES];
+  }
+}
+
+function appleScriptList(values) {
+  return `{${values.map((value) => JSON.stringify(String(value))).join(", ")}}`;
+}
+
+export function buildFocusScript({ agentId, appCandidates } = {}) {
+  const candidates = Array.isArray(appCandidates)
+    ? appCandidates.map(String).filter(Boolean)
+    : getFocusCandidates({ agentId });
+  return `
+set appCandidates to ${appleScriptList(candidates)}
+tell application "System Events"
+  set runningNames to name of every process
+end tell
+repeat with appName in appCandidates
+  set appText to appName as text
+  if runningNames contains appText then
+    tell application appText to activate
+    return "activated " & appText
+  end if
+end repeat
+return "no focus candidate running"
+`;
+}
+
+export function focusSessionOnMac(target = {}, maybeUdsId = null) {
+  const normalizedTarget =
+    target && typeof target === "object"
+      ? target
+      : { sessionId: target, udsId: maybeUdsId };
+  const script = buildFocusScript({ agentId: normalizedTarget.agentId });
+  return new Promise((resolve) => {
+    execFile(
+      "osascript",
+      ["-e", script],
+      { timeout: FOCUS_SCRIPT_TIMEOUT_MS },
+      (err, stdout = "", stderr = "") => {
+        const output = String(stdout || stderr || "").trim();
+        if (err) {
+          console.error("mac-focus error:", err?.message || err);
+          resolve({
+            ok: false,
+            sessionId: normalizedTarget.sessionId || null,
+            pid: Number(normalizedTarget.pid) || null,
+            agentId: normalizedTarget.agentId || null,
+            error: err?.message || String(err),
+            output,
+          });
+          return;
+        }
+        resolve({
+          ok: true,
+          sessionId: normalizedTarget.sessionId || null,
+          pid: Number(normalizedTarget.pid) || null,
+          agentId: normalizedTarget.agentId || null,
+          output,
+        });
+      },
+    );
+  });
+}

package/hub/mac-tray.swift

@@ -0,0 +1,133 @@
+import Cocoa
+import WebKit
+
+class AppDelegate: NSObject, NSApplicationDelegate, NSPopoverDelegate {
+    var statusItem: NSStatusItem!
+    var popover: NSPopover!
+    var webVC: WebViewController!
+    var port: String = "27888"
+
+    func applicationDidFinishLaunching(_ aNotification: Notification) {
+        if CommandLine.arguments.count > 1 {
+            port = CommandLine.arguments[1]
+        }
+
+        statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
+        if let button = statusItem.button {
+            button.title = "T"
+            button.target = self
+            button.action = #selector(togglePopover(_:))
+        }
+
+        webVC = WebViewController()
+        webVC.port = port
+        webVC.onFocusComplete = { [weak self] in
+            self?.popover.performClose(nil)
+        }
+
+        popover = NSPopover()
+        popover.contentViewController = webVC
+        popover.behavior = .transient
+        popover.animates = false
+        popover.delegate = self
+    }
+
+    @objc func togglePopover(_ sender: Any?) {
+        if popover.isShown {
+            popover.performClose(sender)
+        } else {
+            if let button = statusItem.button {
+                webVC.reloadForPopover()
+                popover.show(relativeTo: button.bounds, of: button, preferredEdge: .minY)
+            }
+        }
+    }
+}
+
+class WebViewController: NSViewController, WKNavigationDelegate, WKScriptMessageHandler {
+    var webView: WKWebView!
+    var port: String = "27888"
+    var retryWorkItem: DispatchWorkItem?
+    var onFocusComplete: (() -> Void)?
+
+    func logError(_ msg: String) {
+        let path = "/tmp/mac-tray.log"
+        if let outputStream = OutputStream(toFileAtPath: path, append: true) {
+            outputStream.open()
+            let text = "\(Date()): \(msg)\n"
+            let bytesWritten = outputStream.write(text, maxLength: text.utf8.count)
+            outputStream.close()
+        }
+    }
+
+    override func loadView() {
+        let webConfiguration = WKWebViewConfiguration()
+        webConfiguration.userContentController.add(self, name: "tray")
+        let initialFrame = NSRect(x: 0, y: 0, width: 320, height: 520)
+        webView = WKWebView(frame: initialFrame, configuration: webConfiguration)
+
+        // Transparent background for Glassmorphism
+        webView.setValue(false, forKey: "drawsBackground")
+
+        self.view = NSView(frame: initialFrame)
+        webView.frame = self.view.bounds
+        webView.autoresizingMask = [.width, .height]
+        self.view.addSubview(webView)
+
+        self.preferredContentSize = initialFrame.size
+    }
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        webView.navigationDelegate = self
+        loadTray()
+    }
+
+    func loadTray() {
+        retryWorkItem?.cancel()
+        if let url = URL(string: "http://127.0.0.1:\(port)/tray.html?t=\(Date().timeIntervalSince1970)") {
+            let request = URLRequest(url: url)
+            webView.load(request)
+        } else {
+            logError("Invalid URL")
+        }
+    }
+
+    func reloadForPopover() {
+        if isViewLoaded {
+            loadTray()
+        }
+    }
+
+    func webView(_ webView: WKWebView, didFailProvisionalNavigation navigation: WKNavigation!, withError error: Error) {
+        logError("Failed to load: \(error.localizedDescription)")
+        let retry = DispatchWorkItem { [weak self] in
+            self?.loadTray()
+        }
+        retryWorkItem = retry
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.35, execute: retry)
+    }
+
+    func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
+        retryWorkItem?.cancel()
+        retryWorkItem = nil
+        logError("Successfully loaded URL")
+    }
+
+    func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {
+        guard message.name == "tray" else { return }
+        if let body = message.body as? [String: Any],
+           let type = body["type"] as? String,
+           type == "focus-complete" {
+            DispatchQueue.main.async { [weak self] in
+                self?.onFocusComplete?()
+            }
+        }
+    }
+}
+
+let app = NSApplication.shared
+let delegate = AppDelegate()
+app.delegate = delegate
+app.setActivationPolicy(.accessory)
+app.run()