@triflux/remote 10.48.1 → 10.50.0

package/hub/server.mjs

@@ -22,13 +22,7 @@ import {
   ListToolsRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 import { runCollect } from "../cto/collect.mjs";
-import { resolveLakeRootDir } from "../cto/lake-root.mjs";
-import { runStatus as runCtoStatus } from "../cto/status.mjs";
 import { createModuleLogger } from "../scripts/lib/logger.mjs";
-import {
-  inspectRegistry,
-  inspectRegistryStatus,
-} from "../scripts/lib/mcp-guard-engine.mjs";
 import { broker as brokerInstance, reloadBroker } from "@triflux/core/hub/account-broker.mjs";
 import { createAdaptiveEngine } from "@triflux/core/hub/adaptive.mjs";
 import { createAssignCallbackServer } from "@triflux/core/hub/assign-callbacks.mjs";
@@ -56,7 +50,6 @@ import {
   recordWorker,
   snapshot as traceSnapshot,
 } from "@triflux/core/hub/lib/trace-recorder.mjs";
-import { focusSessionOnMac } from "./mac-focus.mjs";
 import { logQuotaRefreshFailures } from "@triflux/core/hub/middleware/quota-middleware.mjs";
 import { wrapRequestHandler } from "@triflux/core/hub/middleware/request-logger.mjs";
 import { createPipeServer } from "./pipe.mjs";
@@ -79,9 +72,6 @@ import {
 } from "./team/synapse-registry.mjs";
 import { registerTeamBridge } from "@triflux/core/hub/team-bridge.mjs";
 import { createTools } from "./tools.mjs";
-import { spawnTrayForHub } from "./tray-lifecycle.mjs";
-import { getRuntimeStatus } from "./tray-runtime.mjs";
-import { buildTrayStatePayload } from "./tray-state.mjs";
 import { createDelegatorMcpWorker } from "./workers/delegator-mcp.mjs";
 
 registerTeamBridge(nativeProxy);
@@ -101,7 +91,6 @@ const LOOPBACK_REMOTE_ADDRESSES = new Set([
 const ALLOWED_ORIGIN_RE =
   /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/i;
 const PROJECT_ROOT = fileURLToPath(new URL("..", import.meta.url));
-const CANONICAL_PROJECT_ROOT = resolveLakeRootDir(PROJECT_ROOT) || PROJECT_ROOT;
 const PUBLIC_DIR = resolve(join(PROJECT_ROOT, "hub", "public"));
 const CACHE_DIR = join(homedir(), ".claude", "cache");
 const HUB_DEFAULT_PORT = 27888;
@@ -498,7 +487,6 @@ function isPublicPath(path) {
   return (
     PUBLIC_PATHS.has(path) ||
     path === "/dashboard" ||
-    path === "/tray.html" ||
     path === "/api/qos-stats" ||
     path.startsWith("/public/")
   );
@@ -861,41 +849,10 @@ function getBrokerPublicSnapshot(currentBroker = brokerInstance) {
   return currentBroker.publicSnapshot();
 }
 
-async function getTrayCtoStatus() {
-  try {
-    return await runCtoStatus(["--json"], {
-      rootDir: CANONICAL_PROJECT_ROOT,
-      stdout: { write() {} },
-    });
-  } catch (error) {
-    return { error: error?.message || String(error) };
-  }
-}
-
-function getTrayMcpStatus() {
-  const registryState = inspectRegistry();
-  if (!registryState.exists || !registryState.valid) {
-    return {
-      registry_path: registryState.path,
-      server_count: 0,
-      rows: [],
-      error: registryState.errors?.join("; ") || "MCP registry unavailable",
-    };
-  }
-  const status = inspectRegistryStatus(registryState.registry);
-  return {
-    registry_path: registryState.path,
-    server_count: Object.keys(registryState.registry?.servers || {}).length,
-    rows: status.rows,
-  };
-}
-
 function resolvePublicFilePath(path) {
   let relativePath = null;
   if (path === "/dashboard") {
     relativePath = "dashboard.html";
-  } else if (path === "/tray.html") {
-    relativePath = "tray.html";
   } else if (path.startsWith("/public/")) {
     relativePath = path.slice("/public/".length);
   }
@@ -1441,76 +1398,6 @@ export async function startHub({
         });
       }
 
-      if (path === "/api/tray-state" && req.method === "GET") {
-        if (!isLoopbackRemoteAddress(req.socket.remoteAddress)) {
-          return writeJson(res, 403, { ok: false, error: "Loopback only" });
-        }
-
-        const qos = getQosStatsPayload();
-        const synapseSnapshot = synapseRegistry.snapshot();
-        const broker = getBrokerPublicSnapshot(brokerInstance);
-        const runtimeStatus = getRuntimeStatus({
-          projectRoots: [
-            ...new Set([CANONICAL_PROJECT_ROOT, PROJECT_ROOT].filter(Boolean)),
-          ],
-        });
-        const [ctoStatus, mcpStatus, hubStatus] = await Promise.all([
-          getTrayCtoStatus(),
-          Promise.resolve(getTrayMcpStatus()),
-          pipe.executeQuery("status", {
-            scope: "hub",
-            include_metrics: true,
-          }),
-        ]);
-        const mergedCtoStatus = {
-          ...(ctoStatus || {}),
-          roles: hubStatus?.data?.roles || ctoStatus?.roles || {},
-        };
-
-        return writeJson(
-          res,
-          200,
-          buildTrayStatePayload({
-            hub: {
-              id: String(sessionId),
-              pid: process.pid,
-              port,
-              url: buildHubUrl(host, port),
-              projectRoot: CANONICAL_PROJECT_ROOT,
-            },
-            qos,
-            synapseSnapshot,
-            broker,
-            ctoStatus: mergedCtoStatus,
-            mcpStatus,
-            runtimeStatus,
-          }),
-        );
-      }
-
-      if (path === "/api/focus-session" && req.method === "POST") {
-        if (!isLoopbackRemoteAddress(req.socket.remoteAddress)) {
-          return writeJson(res, 403, { ok: false, error: "Loopback only" });
-        }
-        let body;
-        try {
-          body = await parseBody(req);
-        } catch (_e) {
-          return writeJson(res, 400, {
-            error: "Invalid JSON or Body too large",
-          });
-        }
-
-        const { sessionId, udsId } = body || {};
-        const result = await focusSessionOnMac({
-          sessionId,
-          udsId,
-          pid: body?.pid,
-          agentId: body?.agentId ?? body?.agent_id,
-        });
-        return writeJson(res, 200, { ok: result.ok !== false, focus: result });
-      }
-
       // Redacted peer-discovery surface. Returns co-located live peers (same
       // cwd / worktree) with raw cwd/pid stripped — only label/hash + booleans.
       if (path === "/synapse/peers" && req.method === "GET") {
@@ -3110,15 +2997,6 @@ if (selfRun) {
         process.exit(0);
         return;
       }
-      try {
-        const trayPath = fileURLToPath(new URL("./tray.mjs", import.meta.url));
-        const tray = spawnTrayForHub({ trayPath });
-        if (tray.status === "started") {
-          hubLog.info({ pid: tray.pid }, "tray.auto_started");
-        }
-      } catch (error) {
-        hubLog.warn({ err: error }, "tray.auto_start_failed");
-      }
       const shutdown = async (signal) => {
         hubLog.info({ signal }, "hub.stopping");
         try {

package/hub/team/claude-daemon-control.mjs

@@ -13,6 +13,10 @@ import {
   removeClaudeSessionProjection,
   writeClaudeSessionProjection,
 } from "./claude-session-projection.mjs";
+import {
+  findClaudeTranscript,
+  readClaudeTranscript,
+} from "./claude-transcript.mjs";
 
 export function resolveClaudeConfigDir(env = process.env) {
   if (env.CLAUDE_CONFIG_DIR) return path.resolve(env.CLAUDE_CONFIG_DIR);
@@ -223,6 +227,21 @@ function sessionsFromDaemonList(listResponse) {
   return extractClaudeAgentSessions(listResponse);
 }
 
+async function addSessionContexts(sessions, candidate) {
+  return await Promise.all(
+    sessions.map(async (session) => {
+      const transcript = await findClaudeTranscript({
+        configDir: candidate.configDir,
+        sourceConfigDir: candidate.sourceConfigDir,
+        sessionId: session.sessionId,
+        cwd: session.cwd,
+      });
+      const snapshot = await readClaudeTranscript(transcript).catch(() => null);
+      return { ...session, context: snapshot?.context ?? null };
+    }),
+  );
+}
+
 function errorMessage(error) {
   return error?.message || String(error);
 }
@@ -322,12 +341,21 @@ export async function probeClaudeDaemonCandidates({
   sessionId,
   timeoutMs = 6000,
   tmpRoot = "/tmp",
+  includeContext = false,
+  candidateSourceConfigDir,
 } = {}) {
-  const candidates = await buildClaudeDaemonDiscoveryCandidates({
+  const discovered = await buildClaudeDaemonDiscoveryCandidates({
     configDir,
     env,
     tmpRoot,
   });
+  const candidates = candidateSourceConfigDir
+    ? discovered.filter(
+        (candidate) =>
+          (candidate.sourceConfigDir ?? candidate.configDir) ===
+          candidateSourceConfigDir,
+      )
+    : discovered;
   const callerProvenance = detectCallerProvenance(env);
   const targetRequested = Boolean(short || sessionId);
   const results = [];
@@ -339,7 +367,10 @@ export async function probeClaudeDaemonCandidates({
         { proto: 1, op: "list" },
         { timeoutMs },
       );
-      const sessions = sessionsFromDaemonList(list);
+      const normalized = sessionsFromDaemonList(list);
+      const sessions = includeContext
+        ? await addSessionContexts(normalized, candidate)
+        : normalized;
       const ok = list?.ok !== false;
       results.push({
         ok,
@@ -1038,10 +1069,10 @@ function defaultClaudeAttachCompletionMatched(
   );
 }
 
-function writeClaudeAttachInput(socket, input) {
+function writeClaudeAttachInput(socket, input, onSubmitted) {
   socket.write("\x15");
   socket.write(`\x1b[200~${String(input)}\x1b[201~`);
-  socket.write("\r");
+  socket.write("\r", onSubmitted);
 }
 
 function requiresPostInputTransition(handshake) {
@@ -1066,6 +1097,7 @@ export function attachClaudeDaemonSession({
   timeoutMs = 30_000,
   completionQuiescenceMs = DEFAULT_ATTACH_COMPLETION_QUIESCENCE_MS,
   completionMatched = defaultClaudeAttachCompletionMatched,
+  noWait = false,
 } = {}) {
   if (!controlSock) throw new Error("controlSock is required");
   return new Promise((resolve, reject) => {
@@ -1198,8 +1230,24 @@ export function attachClaudeDaemonSession({
               { cols },
             );
             responseStartOffset = stream.length;
-            writeClaudeAttachInput(socket, input);
-            inputSent = true;
+            inputSent = noWait ? null : true;
+            writeClaudeAttachInput(
+              socket,
+              input,
+              noWait
+                ? (error) => {
+                    if (error) fail(error);
+                    else {
+                      inputSent = true;
+                      finish({
+                        timedOut: false,
+                        matchedCompletion: false,
+                        closed: false,
+                      });
+                    }
+                  }
+                : undefined,
+            );
           }, initialDrainMs);
         }
       } else {

package/hub/team/claude-transcript.mjs

@@ -0,0 +1,240 @@
+import { createReadStream } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { modelContext } from "./session-context.mjs";
+
+const transcriptCache = new Map();
+
+export async function findClaudeTranscript({
+  configDir,
+  sourceConfigDir,
+  sessionId,
+  cwd,
+}) {
+  if (!configDir || !sessionId || /[/\\]/u.test(sessionId)) return null;
+  for (const dir of new Set([configDir, sourceConfigDir].filter(Boolean))) {
+    const projectsDir = path.join(dir, "projects");
+    const preferred = cwd
+      ? path.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-")
+      : null;
+    const projects = [
+      ...(preferred ? [preferred] : []),
+      ...(await fs.readdir(projectsDir).catch(() => [])).filter(
+        (project) => project !== preferred,
+      ),
+    ];
+    for (const project of projects) {
+      const candidate = path.join(projectsDir, project, `${sessionId}.jsonl`);
+      try {
+        await fs.access(candidate);
+        return candidate;
+      } catch {
+        // Continue looking for this session.
+      }
+    }
+  }
+  return null;
+}
+
+function messageText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((part) => part?.type === "text" && typeof part.text === "string")
+    .map((part) => part.text)
+    .join("\n");
+}
+
+function beginTurn(state) {
+  state.userSeen = true;
+  state.queued = false;
+  state.response = "";
+  state.error = null;
+  state.turnEnded = false;
+  state.sectionClosed = false;
+}
+
+function acceptEntry(state, entry, marker) {
+  if (entry?.isSidechain) return;
+  const message = entry?.message;
+  if (entry?.type === "system" && entry.subtype === "compact_boundary") {
+    state.compactCount += 1;
+    state.compact = {
+      preTokens: entry.compactMetadata?.preTokens ?? null,
+      postTokens: entry.compactMetadata?.postTokens ?? null,
+    };
+    state.estimatedContextTokens = state.compact.postTokens;
+    state.measuredAt = entry.timestamp || null;
+  }
+  if (entry?.type === "assistant") {
+    if (entry.isApiErrorMessage === true || message?.model === "<synthetic>") {
+      if (state.userSeen && !state.sectionClosed && entry.isApiErrorMessage) {
+        state.error = messageText(message?.content) || "Claude API error";
+        state.turnEnded = true;
+      }
+      return;
+    }
+    const usage = message?.usage;
+    if (usage) {
+      state.estimatedContextTokens =
+        (usage.input_tokens || 0) +
+        (usage.cache_read_input_tokens || 0) +
+        (usage.cache_creation_input_tokens || 0);
+      state.model = message.model || state.model;
+      state.measuredAt = entry.timestamp || state.measuredAt;
+    }
+    if (state.userSeen && !state.sectionClosed) {
+      const text = messageText(message?.content);
+      if (text) state.response = text;
+      if (message?.stop_reason === "end_turn") state.turnEnded = true;
+    }
+    return;
+  }
+  if (entry?.type === "user") {
+    const content = message?.content;
+    // Tool results are not a new human turn.
+    const humanText =
+      typeof content === "string" ||
+      (Array.isArray(content) && content.some((part) => part?.type === "text"))
+        ? messageText(content)
+        : "";
+    const marked =
+      marker &&
+      (humanText.includes(marker) ||
+        JSON.stringify(
+          entry.attachments ?? message?.attachments ?? [],
+        ).includes(marker));
+    if (humanText || marked) {
+      if (!marker || marked) beginTurn(state);
+      else if (state.userSeen) state.sectionClosed = true;
+    }
+    return;
+  }
+  if (
+    entry?.type === "attachment" &&
+    entry.attachment?.type === "queued_command" &&
+    marker &&
+    JSON.stringify(entry.attachment).includes(marker)
+  ) {
+    beginTurn(state);
+    return;
+  }
+  if (entry?.type === "queue-operation") {
+    const marked =
+      marker &&
+      typeof entry.content === "string" &&
+      entry.content.includes(marker);
+    if (marked && entry.operation === "enqueue") {
+      state.queued = true;
+      state.queuedContent = entry.content;
+    } else if (
+      state.queued &&
+      (marked || entry.content === state.queuedContent)
+    ) {
+      if (entry.operation === "remove") beginTurn(state);
+    } else if (marked && entry.operation === "remove") {
+      beginTurn(state);
+    }
+    return;
+  }
+  if (
+    state.userSeen &&
+    !state.sectionClosed &&
+    entry?.type === "system" &&
+    entry.subtype === "turn_duration"
+  ) {
+    state.turnEnded = true;
+  }
+}
+
+function acceptLine(state, line, marker) {
+  try {
+    acceptEntry(state, JSON.parse(line), marker);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function readClaudeTranscript(transcriptPath, { requestId } = {}) {
+  if (!transcriptPath) return null;
+  const marker = requestId ? `[tfx-live req=${requestId}]` : null;
+  const key = `${transcriptPath}\0${requestId || ""}`;
+  let stat;
+  try {
+    stat = await fs.stat(transcriptPath);
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+  let state = transcriptCache.get(key);
+  if (
+    !state ||
+    state.ino !== stat.ino ||
+    stat.size < state.offset ||
+    (stat.size === state.offset && stat.mtimeMs !== state.mtimeMs)
+  ) {
+    state = {
+      ino: stat.ino,
+      offset: 0,
+      pending: "",
+      decoder: new StringDecoder("utf8"),
+      userSeen: false,
+      queued: false,
+      queuedContent: null,
+      response: "",
+      error: null,
+      turnEnded: false,
+      sectionClosed: false,
+      estimatedContextTokens: null,
+      model: null,
+      measuredAt: null,
+      compactCount: 0,
+      compact: null,
+    };
+  }
+  try {
+    if (stat.size > state.offset) {
+      const stream = createReadStream(transcriptPath, {
+        start: state.offset,
+        end: stat.size - 1,
+      });
+      for await (const chunk of stream) {
+        const lines = (state.pending + state.decoder.write(chunk)).split("\n");
+        state.pending = lines.pop();
+        for (const line of lines) acceptLine(state, line, marker);
+      }
+      if (state.pending && acceptLine(state, state.pending, marker))
+        state.pending = "";
+    }
+  } catch (error) {
+    transcriptCache.delete(key);
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+  state.offset = stat.size;
+  state.mtimeMs = stat.mtimeMs;
+  transcriptCache.set(key, state);
+  return {
+    context:
+      state.estimatedContextTokens === null && state.model === null
+        ? null
+        : {
+            ...modelContext(
+              "claude",
+              state.model,
+              state.estimatedContextTokens,
+            ),
+            model: state.model,
+            measuredAt: state.measuredAt,
+          },
+    userSeen: state.userSeen,
+    response: state.response,
+    error: state.error,
+    turnEnded: state.turnEnded,
+    sectionClosed: state.sectionClosed,
+    compactCount: state.compactCount,
+    compact: state.compact,
+  };
+}

package/hub/team/cli/commands/start/index.mjs

@@ -72,9 +72,19 @@ function renderTmuxInstallHelp() {
 
 export { parseTeamArgs };
 
+export function resolveTeamWorkers({ agents, task, assigns = [] }) {
+  if (assigns.length > 0) {
+    return {
+      agents: assigns.map((assign) => assign.cli),
+      subtasks: assigns.map((assign) => assign.prompt),
+    };
+  }
+  return { agents, subtasks: decomposeTask(task, agents.length) };
+}
+
 export async function teamStart(args = []) {
   const {
-    agents,
+    agents: requestedAgents,
     lead,
     layout,
     teammateMode,
@@ -100,11 +110,16 @@ export async function teamStart(args = []) {
     rawTask ||
     (assigns.length > 0 ? assigns.map((a) => a.prompt).join(" + ") : "");
   if (!task) return printStartUsage();
+  const { agents, subtasks } = resolveTeamWorkers({
+    agents: requestedAgents,
+    task,
+    assigns,
+  });
 
   console.log(`\n  ${AMBER}${BOLD}⬡ tfx multi${RESET}\n`);
 
   // P1b: 워커 수 계산 — 단일 워커 headless에는 Hub 불필요
-  const workerCount = assigns.length > 0 ? assigns.length : agents.length;
+  const workerCount = agents.length;
   const needsHub = workerCount >= 2 || teammateMode !== "headless";
 
   let hub = null;
@@ -126,7 +141,6 @@ export async function teamStart(args = []) {
   }
 
   const sessionId = `tfx-multi-${Date.now().toString(36).slice(-4)}${Math.random().toString(36).slice(2, 6)}`;
-  const subtasks = decomposeTask(task, agents.length);
   const hubUrl = hub?.url || getDefaultHubUrl();
   const { mode: effectiveMode, warnings: modeWarnings } =
     resolveEffectiveMode(teammateMode);

package/hub/team/cli/commands/start/parse-args.mjs

@@ -25,6 +25,7 @@ const KNOWN_ROLES = new Set([
   "test-engineer",
   "designer",
   "writer",
+  "researcher",
   "scientist",
 ]);