@triflux/remote 10.31.0 → 10.33.0

package/hub/tray-state.mjs

@@ -0,0 +1,448 @@
+// hub/tray-state.mjs — normalize Hub/CTO/MCP state for the macOS tray UI
+
+function toIsoTime(value) {
+  if (typeof value === "string" && value.trim()) return value;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return new Date(value).toISOString();
+  }
+  return null;
+}
+
+function statusRank(status) {
+  switch (status) {
+    case "active":
+      return 0;
+    case "idle":
+      return 1;
+    case "starting":
+      return 2;
+    case "stale":
+      return 4;
+    default:
+      return 3;
+  }
+}
+
+function readSynapseSessions(snapshot) {
+  if (Array.isArray(snapshot)) return snapshot;
+  if (Array.isArray(snapshot?.sessions)) return snapshot.sessions;
+  if (snapshot && typeof snapshot === "object") {
+    return Object.values(snapshot).filter(
+      (entry) => entry && typeof entry === "object" && entry.sessionId,
+    );
+  }
+  return [];
+}
+
+const MCP_CLIENTS = Object.freeze([
+  { id: "claude", label: "Claude", icon: "C", color: "#d19a66" },
+  { id: "codex", label: "Codex", icon: "X", color: "#ffffff" },
+  { id: "antigravity", label: "Antigravity", icon: "A", color: "#61afef" },
+]);
+
+function normalizeAgentId(value) {
+  const id = String(value || "")
+    .trim()
+    .toLowerCase();
+  if (id === "agy" || id === "anti") return "antigravity";
+  if (id === "claude" || id === "codex" || id === "antigravity") return id;
+  return "";
+}
+
+function inferAgentId(value = {}) {
+  const direct = normalizeAgentId(
+    value.agent_id ??
+      value.agentId ??
+      value.client ??
+      value.provider ??
+      value.runtimeClient,
+  );
+  if (direct) return direct;
+  const haystack = [
+    value.sessionId,
+    value.sessionKind,
+    value.role,
+    value.taskSummary,
+    value.command,
+  ]
+    .filter(Boolean)
+    .join(" ")
+    .toLowerCase();
+  for (const id of ["claude", "codex", "antigravity"]) {
+    if (haystack.includes(id)) return id;
+  }
+  if (haystack.includes("agy")) return "antigravity";
+  return "";
+}
+
+function agentMeta(agentId) {
+  const id = normalizeAgentId(agentId);
+  const meta = MCP_CLIENTS.find((client) => client.id === id);
+  return meta ? { ...meta } : null;
+}
+
+export function normalizeTraySessions(snapshot) {
+  return readSynapseSessions(snapshot)
+    .map((session) => {
+      const agentId = inferAgentId(session);
+      return {
+        sessionId: String(session?.sessionId || ""),
+        host: typeof session?.host === "string" ? session.host : "local",
+        status:
+          typeof session?.status === "string"
+            ? session.status
+            : typeof session?.phase === "string"
+              ? session.phase
+              : "active",
+        sessionKind:
+          typeof session?.sessionKind === "string"
+            ? session.sessionKind
+            : "interactive",
+        cwd: typeof session?.cwd === "string" ? session.cwd : "",
+        worktreePath:
+          typeof session?.worktreePath === "string" ? session.worktreePath : "",
+        branch: typeof session?.branch === "string" ? session.branch : "",
+        taskSummary:
+          typeof session?.taskSummary === "string" ? session.taskSummary : "",
+        agent_id: agentId || null,
+        agent: agentMeta(agentId),
+        lastHeartbeat: Number.isFinite(Number(session?.lastHeartbeat))
+          ? Number(session.lastHeartbeat)
+          : null,
+        started_at: toIsoTime(
+          session?.started_at ?? session?.startedAt ?? session?.lastHeartbeat,
+        ),
+        isRemote: session?.isRemote === true,
+      };
+    })
+    .filter((session) => session.sessionId)
+    .sort((a, b) => {
+      const rankDelta = statusRank(a.status) - statusRank(b.status);
+      if (rankDelta !== 0) return rankDelta;
+      return (b.lastHeartbeat || 0) - (a.lastHeartbeat || 0);
+    });
+}
+
+function countBy(items, pickKey) {
+  const counts = {};
+  for (const item of Array.isArray(items) ? items : []) {
+    const key = pickKey(item) || "unknown";
+    counts[key] = (counts[key] || 0) + 1;
+  }
+  return counts;
+}
+
+function sanitizeMcpRow(row) {
+  return {
+    type: String(row?.type || ""),
+    name: String(row?.name || ""),
+    client: String(row?.client || ""),
+    label: String(row?.label || ""),
+    filePath: String(row?.filePath || ""),
+    expectedUrl: String(row?.expectedUrl || ""),
+    expectedCommand: String(row?.expectedCommand || ""),
+    actualUrl: String(row?.actualUrl || ""),
+    actualCommand: String(row?.actualCommand || ""),
+    status: String(row?.status || ""),
+    headerStatus: String(row?.headerStatus || ""),
+    expectedHeaderNames: Array.isArray(row?.expectedHeaderNames)
+      ? row.expectedHeaderNames.map(String)
+      : [],
+    actualHeaderNames: Array.isArray(row?.actualHeaderNames)
+      ? row.actualHeaderNames.map(String)
+      : [],
+    command: row?.command ? String(row.command) : "",
+  };
+}
+
+function summarizeMcpClients(rows) {
+  return MCP_CLIENTS.map((client) => {
+    const clientRows = rows.filter(
+      (row) => row.type === "registry" && row.client === client.id,
+    );
+    const present = clientRows.filter(
+      (row) => row.status === "present" || row.status === "ok",
+    ).length;
+    const total = clientRows.length;
+    let status = "off";
+    if (total > 0 && present === total) status = "on";
+    else if (present > 0) status = "partial";
+    return {
+      ...client,
+      status,
+      present,
+      total,
+    };
+  });
+}
+
+function summarizeMcpServers(rows) {
+  const grouped = new Map();
+  for (const row of rows) {
+    if (row.type !== "registry" || !row.name) continue;
+    if (!grouped.has(row.name)) {
+      grouped.set(row.name, {
+        name: row.name,
+        target:
+          row.expectedUrl ||
+          row.actualUrl ||
+          row.expectedCommand ||
+          row.actualCommand ||
+          "",
+        rows: [],
+      });
+    }
+    const group = grouped.get(row.name);
+    if (!group.target) {
+      group.target =
+        row.expectedUrl ||
+        row.actualUrl ||
+        row.expectedCommand ||
+        row.actualCommand ||
+        "";
+    }
+    group.rows.push(row);
+  }
+
+  return [...grouped.values()]
+    .map((server) => {
+      const clients = MCP_CLIENTS.map((client) => {
+        const clientRows = server.rows.filter(
+          (row) => row.client === client.id,
+        );
+        if (clientRows.length === 0) return null;
+        const present = clientRows.filter(
+          (row) => row.status === "present" || row.status === "ok",
+        ).length;
+        let status = "off";
+        if (present === clientRows.length) status = "on";
+        else if (present > 0) status = "partial";
+        return {
+          ...client,
+          status,
+          present,
+          total: clientRows.length,
+          labels: [
+            ...new Set(clientRows.map((row) => row.label).filter(Boolean)),
+          ],
+        };
+      }).filter(Boolean);
+      const onCount = clients.filter((client) => client.status === "on").length;
+      const partialCount = clients.filter(
+        (client) => client.status === "partial",
+      ).length;
+      let status = "off";
+      if (clients.length > 0 && onCount === clients.length) status = "on";
+      else if (onCount > 0 || partialCount > 0) status = "partial";
+      return {
+        name: server.name,
+        target: server.target,
+        status,
+        clients,
+        client_count: clients.length,
+        present_client_count: onCount,
+      };
+    })
+    .sort((a, b) => {
+      if (a.name === "tfx-hub") return -1;
+      if (b.name === "tfx-hub") return 1;
+      return a.name.localeCompare(b.name);
+    });
+}
+
+function normalizeMcpStatus(mcpStatus = {}) {
+  const rows = Array.isArray(mcpStatus?.rows)
+    ? mcpStatus.rows.map(sanitizeMcpRow)
+    : [];
+  return {
+    registry_path: String(
+      mcpStatus?.registry_path || mcpStatus?.registryPath || "",
+    ),
+    server_count: Number.isFinite(Number(mcpStatus?.server_count))
+      ? Number(mcpStatus.server_count)
+      : Number.isFinite(Number(mcpStatus?.serverCount))
+        ? Number(mcpStatus.serverCount)
+        : 0,
+    rows,
+    clients: summarizeMcpClients(rows),
+    servers: summarizeMcpServers(rows),
+    summary: {
+      total: rows.length,
+      by_status: countBy(rows, (row) => row.status),
+      by_client: countBy(rows, (row) => row.client || row.label),
+    },
+    ...(mcpStatus?.error ? { error: String(mcpStatus.error) } : {}),
+  };
+}
+
+function normalizeHub(hub = {}) {
+  const id = String(hub?.id ?? hub?.sessionId ?? hub?.session_id ?? "");
+  return {
+    id,
+    pid: Number.isFinite(Number(hub?.pid)) ? Number(hub.pid) : null,
+    port: Number.isFinite(Number(hub?.port)) ? Number(hub.port) : null,
+    url: String(hub?.url || ""),
+    projectRoot: String(hub?.projectRoot || hub?.project_root || ""),
+  };
+}
+
+function numericPid(value) {
+  const text = String(value ?? "").trim();
+  if (!text) return null;
+  const pid = Number(text);
+  return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+
+function normalizeRuntimeStatus(runtimeStatus = {}) {
+  const processes = Array.isArray(runtimeStatus?.processes)
+    ? runtimeStatus.processes.map((process) => ({
+        client: String(process?.client || ""),
+        sessionId: String(process?.sessionId || ""),
+        source: String(process?.source || ""),
+        conversationId: String(process?.conversationId || ""),
+        focusable: process?.focusable !== false,
+        pid: numericPid(process?.pid),
+        ppid: Number.isFinite(Number(process?.ppid))
+          ? Number(process.ppid)
+          : null,
+        phase:
+          typeof process?.phase === "string"
+            ? process.phase
+            : process?.source === "conversation"
+              ? "idle"
+              : "active",
+        elapsed: String(process?.elapsed || ""),
+        command: String(process?.command || ""),
+        cwd: String(process?.cwd || ""),
+        taskSummary: String(process?.taskSummary || process?.command || ""),
+      }))
+    : [];
+  return {
+    processes: processes.filter(
+      (process) =>
+        process.client &&
+        (process.pid || process.sessionId || process.conversationId),
+    ),
+    summary: runtimeStatus?.summary || {
+      total: processes.length,
+      clients: [],
+    },
+    ...(runtimeStatus?.error ? { error: String(runtimeStatus.error) } : {}),
+  };
+}
+
+function sessionsToLiveOverlay(sessions = []) {
+  return sessions
+    .filter((session) => session.status !== "stale")
+    .map((session) => ({
+      sessionId: session.sessionId,
+      host: session.host,
+      agent_id: session.agent_id,
+      agent: session.agent,
+      phase: session.status,
+      started_at: session.started_at,
+    }));
+}
+
+function runtimeToLiveOverlay(runtime) {
+  return runtime.processes.map((process) => ({
+    sessionId:
+      process.sessionId ||
+      (process.pid
+        ? `${process.client}-${process.pid}`
+        : `${process.client}-${process.conversationId || "session"}`),
+    host: "local",
+    agent_id: process.client,
+    agent: agentMeta(process.client),
+    phase: process.phase || "active",
+    pid: process.pid,
+    command: process.command,
+    elapsed: process.elapsed,
+    cwd: process.cwd,
+    taskSummary: process.taskSummary || process.command || `PID ${process.pid}`,
+    source: process.source,
+    conversationId: process.conversationId,
+    focusable: process.focusable,
+    started_at: null,
+  }));
+}
+
+function normalizeLiveSession(session = {}) {
+  const agentId = inferAgentId(session);
+  return {
+    ...session,
+    sessionId: String(session.sessionId || ""),
+    host: typeof session.host === "string" ? session.host : "local",
+    agent_id: agentId || null,
+    agent: session.agent || agentMeta(agentId),
+    phase:
+      typeof session.phase === "string"
+        ? session.phase
+        : typeof session.status === "string"
+          ? session.status
+          : "active",
+    started_at: toIsoTime(
+      session.started_at ?? session.startedAt ?? session.lastHeartbeat,
+    ),
+  };
+}
+
+function normalizeCtoStatus(ctoStatus = {}, sessions = [], runtime = {}) {
+  const explicitLive = Array.isArray(ctoStatus?.live_sessions)
+    ? ctoStatus.live_sessions
+    : null;
+  const sessionLive = sessionsToLiveOverlay(sessions);
+  const runtimeLive = runtimeToLiveOverlay(runtime);
+  const overlayLive =
+    explicitLive && explicitLive.length > 0
+      ? explicitLive
+      : sessionLive.length > 0
+        ? sessionLive
+        : runtimeLive;
+  const liveSessions =
+    runtimeLive.length > overlayLive.length ? runtimeLive : overlayLive;
+  const normalizedLiveSessions = liveSessions
+    .map(normalizeLiveSession)
+    .filter((session) => session.sessionId);
+  const activeShards = Array.isArray(ctoStatus?.active_shards)
+    ? ctoStatus.active_shards
+    : [];
+  return {
+    schema_version: String(ctoStatus?.schema_version || "cto-lake.v1"),
+    generated_at: ctoStatus?.generated_at || null,
+    live_sessions: normalizedLiveSessions,
+    active_shards: activeShards,
+    summary: {
+      live_session_count: normalizedLiveSessions.length,
+      active_shard_count: activeShards.length,
+      tray_session_count: sessions.length,
+      tray_sessions_by_status: countBy(sessions, (session) => session.status),
+    },
+    ...(ctoStatus?.error ? { error: String(ctoStatus.error) } : {}),
+  };
+}
+
+export function buildTrayStatePayload({
+  hub = {},
+  qos = {},
+  synapseSnapshot = {},
+  broker = [],
+  ctoStatus = {},
+  mcpStatus = {},
+  runtimeStatus = {},
+  now = Date.now(),
+} = {}) {
+  const sessions = normalizeTraySessions(synapseSnapshot);
+  const runtime = normalizeRuntimeStatus(runtimeStatus);
+  return {
+    ok: true,
+    hub: normalizeHub(hub),
+    qos,
+    sessions,
+    cto: normalizeCtoStatus(ctoStatus, sessions, runtime),
+    mcp: normalizeMcpStatus(mcpStatus),
+    runtime,
+    broker: Array.isArray(broker) ? broker : [],
+    ts: now,
+  };
+}

package/hub/tray.mjs

@@ -4,16 +4,71 @@ import _SysTrayModule from "systray2";
 
 const SysTray = _SysTrayModule.default || _SysTrayModule;
 
-import { exec } from "node:child_process";
+import { exec, execFileSync, spawn } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { IS_WINDOWS } from "@triflux/core/hub/platform.mjs";
+import { IS_MAC, IS_WINDOWS } from "@triflux/core/hub/platform.mjs";
+import { ensureHubForTray } from "./tray-lifecycle.mjs";
 
 const HUB_PID_FILE = join(homedir(), ".claude", "cache", "tfx-hub", "hub.pid");
 const DEFAULT_HUB_PORT = "27888";
 
+function sleep(ms) {
+  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+
+export function collectMacTrayProcesses(
+  psOutput = "",
+  {
+    scriptPath = fileURLToPath(import.meta.url),
+    currentPid = process.pid,
+  } = {},
+) {
+  const target = String(scriptPath || "");
+  if (!target) return [];
+  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 (!command.includes(target)) return [];
+      if (!/\bnode(?:\s|$)|\/node(?:\s|$)/u.test(command)) return [];
+      return [{ pid, ppid, command }];
+    });
+}
+
+export function reapExistingMacTrayProcesses({
+  scriptPath = fileURLToPath(import.meta.url),
+  currentPid = process.pid,
+  execFileSyncFn = execFileSync,
+  killFn = process.kill,
+} = {}) {
+  let output = "";
+  try {
+    output = execFileSyncFn("ps", ["-axo", "pid,ppid,command"], {
+      encoding: "utf8",
+      timeout: 1000,
+      maxBuffer: 1024 * 1024,
+    });
+  } catch {
+    return [];
+  }
+  const existing = collectMacTrayProcesses(output, { scriptPath, currentPid });
+  for (const processInfo of existing) {
+    try {
+      killFn(processInfo.pid, "SIGTERM");
+    } catch {}
+  }
+  return existing;
+}
+
 function getHubBaseUrl() {
   if (process.env.TFX_HUB_URL)
     return process.env.TFX_HUB_URL.replace(/\/+$/, "");
@@ -354,8 +409,42 @@ async function shutdown(reason = "shutdown") {
 }
 
 export async function startTray() {
+  if (IS_MAC) {
+    const trayScript = fileURLToPath(import.meta.url);
+    const port = process.env.TFX_HUB_PORT || DEFAULT_HUB_PORT;
+    const serverPath = join(dirname(trayScript), "server.mjs");
+    await ensureHubForTray({ port, serverPath });
+    const reaped = reapExistingMacTrayProcesses({ scriptPath: trayScript });
+    if (reaped.length > 0) await sleep(350);
+    const swiftScript = join(dirname(trayScript), "mac-tray.swift");
+
+    // Spawn swift script detached or as a child
+    const trayProc = spawn("swift", [swiftScript, port], {
+      stdio: "ignore",
+      detached: false,
+    });
+
+    trayProc.on("error", (err) =>
+      console.error("[tfx-tray-mac] start failed:", err),
+    );
+
+    trayProc.on("exit", (code) => {
+      console.error(`[tfx-tray-mac] swift script exited (code ${code})`);
+      process.exit(typeof code === "number" ? code : 1);
+    });
+
+    const cleanup = () => trayProc.kill();
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+
+    return {
+      systray: null,
+      stop: () => trayProc.kill(),
+    };
+  }
+
   if (!IS_WINDOWS) {
-    throw new Error("tray command is only supported on Windows.");
+    throw new Error("systray2 tray command is only supported on Windows.");
   }
 
   systray = new SysTray({

package/hub/workers/antigravity-route-worker.mjs

@@ -16,7 +16,11 @@ function resolveCandidatePath(candidate, cwd = process.cwd()) {
   return existsSync(normalized) ? normalized : null;
 }
 
-function resolveRouteScript(explicitPath, cwd = process.cwd(), env = process.env) {
+function resolveRouteScript(
+  explicitPath,
+  cwd = process.cwd(),
+  env = process.env,
+) {
   const candidates = [
     explicitPath,
     env.TFX_DELEGATOR_ROUTE_SCRIPT,
@@ -57,10 +61,15 @@ export class AntigravityRouteWorker {
   constructor(options = {}) {
     this.cwd = options.cwd || process.cwd();
     this.env = { ...process.env, ...(options.env || {}) };
-    this.routeScript = resolveRouteScript(options.routeScript, this.cwd, this.env);
+    this.routeScript = resolveRouteScript(
+      options.routeScript,
+      this.cwd,
+      this.env,
+    );
     this.bashCommand = options.bashCommand || this.env.BASH_BIN || "bash";
     this.timeoutMs =
-      Number.isFinite(Number(options.timeoutMs)) && Number(options.timeoutMs) > 0
+      Number.isFinite(Number(options.timeoutMs)) &&
+      Number(options.timeoutMs) > 0
         ? Number(options.timeoutMs)
         : DEFAULT_TIMEOUT_MS;
     this.children = new Set();
@@ -89,7 +98,8 @@ export class AntigravityRouteWorker {
     }
 
     const timeoutMs =
-      Number.isFinite(Number(options.timeoutMs)) && Number(options.timeoutMs) > 0
+      Number.isFinite(Number(options.timeoutMs)) &&
+      Number(options.timeoutMs) > 0
         ? Number(options.timeoutMs)
         : this.timeoutMs;
     const timeoutSec = Math.max(1, Math.ceil(timeoutMs / 1000));

package/hub/workers/delegator-mcp.mjs

@@ -29,11 +29,8 @@ if (!mcpFilterPath) {
     `mcp-filter.mjs not found. candidates: ${MCP_FILTER_CANDIDATES.join(", ")}`,
   );
 }
-const {
-  buildPromptHint,
-  getCodexMcpConfig,
-  SUPPORTED_MCP_PROFILES,
-} = await import(pathToFileURL(mcpFilterPath).href);
+const { buildPromptHint, getCodexMcpConfig, SUPPORTED_MCP_PROFILES } =
+  await import(pathToFileURL(mcpFilterPath).href);
 const SERVER_INFO = { name: "triflux-delegator", version: "1.0.0" };
 const DEFAULT_CONTEXT_BYTES = 32 * 1024;
 const DEFAULT_ROUTE_TIMEOUT_SEC = 120;

package/hub/workers/factory.mjs

@@ -14,8 +14,8 @@
 // existing `requestJson` helper. Callers can override by passing their own
 // `publishCallback` or swap the transport with `requestJsonFn`.
 
-import { ClaudeWorker } from "./claude-worker.mjs";
 import { AntigravityRouteWorker } from "./antigravity-route-worker.mjs";
+import { ClaudeWorker } from "./claude-worker.mjs";
 import { CodexAppServerWorker } from "./codex-app-server-worker.mjs";
 
 /**

package/hub/workers/gemini-worker.mjs

@@ -102,7 +102,8 @@ function detectAntigravityCategory(error) {
 function buildAntigravityErrorInfo(error, attempts) {
   const category = detectAntigravityCategory(error);
   const retryable = isAntigravityRetryable(error);
-  let recovery = "Retry the Antigravity route worker after correcting the issue.";
+  let recovery =
+    "Retry the Antigravity route worker after correcting the issue.";
 
   if (category === "auth") {
     recovery = "Refresh the Antigravity authentication state and retry.";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/remote",
-  "version": "10.31.0",
+  "version": "10.33.0",
   "description": "triflux remote — team mode, psmux, MCP workers, SQLite store.",
   "type": "module",
   "main": "hub/index.mjs",
@@ -16,11 +16,16 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
+    "ajv": "^8.18.0",
     "better-sqlite3": "^12.10.0",
-    "systray2": "^2.1.4"
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
+    "systray2": "^2.1.4",
+    "zod": "^4.0.0"
   },
   "files": [
     "hub",
+    "cto",
     "scripts/lib"
   ],
   "keywords": [