@triflux/remote 10.48.1 → 10.50.0

package/hub/team/session-context.mjs

@@ -0,0 +1,203 @@
+import { createReadStream } from "node:fs";
+import fs from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
+
+// https://platform.claude.com/docs/en/build-with-claude/context-windows 2026-10-08
+// https://developers.openai.com/api/docs/models 2026-10-08
+const MODEL_CONTEXT = [
+  {
+    cli: "claude",
+    model: /^(?:claude-)?(?:fable-5[.-]1|opus-5[.-]5|sonnet-5[.-]5)(?:$|[-[])/i,
+    tokens: 1_000_000,
+    source:
+      "https://platform.claude.com/docs/en/build-with-claude/context-windows",
+  },
+  {
+    cli: "codex",
+    model: /^gpt-6(?:\.\d+)?(?:$|[-_])/i,
+    tokens: 1_050_000,
+    source: "https://developers.openai.com/api/docs/models",
+  },
+];
+
+export const CONTEXT_THRESHOLDS = {
+  claude: { warnContextPct: 60, maxContextPct: 90 },
+  codex: { warnContextPct: 15, maxContextPct: 22 },
+};
+
+const rolloutCache = new Map();
+
+export function modelContext(cli, model, estimatedContextTokens = null) {
+  const entry = MODEL_CONTEXT.find(
+    (item) => item.cli === cli && item.model.test(model || ""),
+  );
+  const contextLimitTokens = entry?.tokens ?? null;
+  const executionContextLimitTokens =
+    cli === "claude" && process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT === "1"
+      ? 200_000
+      : null;
+  const effectiveLimit = Math.min(
+    contextLimitTokens ?? Infinity,
+    executionContextLimitTokens ?? Infinity,
+  );
+  return {
+    estimatedContextTokens,
+    contextLimitTokens,
+    contextLimitSource: entry?.source ?? null,
+    ...(executionContextLimitTokens ? { executionContextLimitTokens } : {}),
+    contextPct:
+      contextLimitTokens && Number.isFinite(estimatedContextTokens)
+        ? (estimatedContextTokens / effectiveLimit) * 100
+        : null,
+  };
+}
+
+export function contextGuard(
+  cli,
+  context,
+  { warnContextPct, maxContextPct } = {},
+) {
+  const defaults = CONTEXT_THRESHOLDS[cli];
+  const warn = warnContextPct ?? defaults?.warnContextPct ?? 0;
+  const max = maxContextPct ?? defaults?.maxContextPct ?? 0;
+  const fields = {
+    estimatedContextTokens: context?.estimatedContextTokens ?? null,
+    contextLimitTokens: context?.contextLimitTokens ?? null,
+    contextLimitSource: context?.contextLimitSource ?? null,
+    executionContextLimitTokens: context?.executionContextLimitTokens ?? null,
+    contextPct: context?.contextPct ?? null,
+  };
+  if (fields.contextPct === null) {
+    return warn > 0
+      ? {
+          contextWarning: {
+            ...fields,
+            reason:
+              fields.contextLimitTokens === null
+                ? "unknown-model"
+                : "usage-unavailable",
+          },
+        }
+      : {};
+  }
+  if (max > 0 && fields.contextPct >= max) {
+    return {
+      ok: false,
+      errorCode: "context-limit",
+      inputSent: false,
+      hint: "세션을 승계한 뒤 새 세션에 요청하라.",
+      ...fields,
+    };
+  }
+  return warn > 0 && fields.contextPct >= warn
+    ? { contextWarning: { ...fields, thresholdPct: warn } }
+    : {};
+}
+
+async function findCodexRollout(threadId) {
+  if (!/^[a-zA-Z0-9-]+$/u.test(threadId || "")) return null;
+  const root = path.join(
+    process.env.CODEX_HOME || path.join(homedir(), ".codex"),
+    "sessions",
+  );
+  for (const year of (await fs.readdir(root).catch(() => []))
+    .sort()
+    .reverse()) {
+    if (!/^\d{4}$/u.test(year)) continue;
+    for (const month of (
+      await fs.readdir(path.join(root, year)).catch(() => [])
+    )
+      .sort()
+      .reverse()) {
+      if (!/^\d{2}$/u.test(month)) continue;
+      for (const day of (
+        await fs.readdir(path.join(root, year, month)).catch(() => [])
+      )
+        .sort()
+        .reverse()) {
+        if (!/^\d{2}$/u.test(day)) continue;
+        const dir = path.join(root, year, month, day);
+        const file = (await fs.readdir(dir).catch(() => [])).find((name) =>
+          name.endsWith(`-${threadId}.jsonl`),
+        );
+        if (file) return path.join(dir, file);
+      }
+    }
+  }
+  return null;
+}
+
+function acceptCodexLine(state, line) {
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return false;
+  }
+  if (entry?.type === "turn_context")
+    state.model = entry.payload?.model || state.model;
+  if (entry?.type === "event_msg" && entry.payload?.type === "token_count") {
+    const info = entry.payload.info;
+    if (Number.isFinite(info?.last_token_usage?.total_tokens))
+      state.tokens = info.last_token_usage.total_tokens;
+    if (Number.isFinite(info?.model_context_window))
+      state.executionContextLimitTokens = info.model_context_window;
+  }
+  return true;
+}
+
+export async function readCodexContext(rolloutPath, threadId) {
+  rolloutPath ||= await findCodexRollout(threadId);
+  if (!rolloutPath) return { ...modelContext("codex", null), model: null };
+  let stat;
+  try {
+    stat = await fs.stat(rolloutPath);
+  } catch {
+    return { ...modelContext("codex", null), model: null };
+  }
+  let state = rolloutCache.get(rolloutPath);
+  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"),
+      model: null,
+      tokens: null,
+      executionContextLimitTokens: null,
+    };
+  }
+  try {
+    if (stat.size > state.offset) {
+      const stream = createReadStream(rolloutPath, {
+        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) acceptCodexLine(state, line);
+      }
+      if (state.pending && acceptCodexLine(state, state.pending))
+        state.pending = "";
+    }
+  } catch {
+    rolloutCache.delete(rolloutPath);
+    return { ...modelContext("codex", null), model: null };
+  }
+  state.offset = stat.size;
+  state.mtimeMs = stat.mtimeMs;
+  rolloutCache.set(rolloutPath, state);
+  return {
+    ...modelContext("codex", state.model, state.tokens),
+    model: state.model,
+    executionContextLimitTokens: state.executionContextLimitTokens,
+  };
+}

package/hub/team/uds-orchestrator.mjs

@@ -18,6 +18,7 @@ import {
   dispatchClaudeDaemonJob,
   teardownClaudeDaemonJob,
 } from "./claude-daemon-control.mjs";
+import { contextGuard, readCodexContext } from "./session-context.mjs";
 
 const DEFAULT_TIMEOUT_MS = 90_000;
 const DEFAULT_CODEX_APP_SERVER_UDS_TIMEOUT_MS = 120_000;
@@ -44,6 +45,7 @@ async function runCodexAppServerTurn({
   timeoutMs,
   maxTurnMs,
   expectedTurnId,
+  noWait = false,
 }) {
   const messages = new Map();
   const pending = [];
@@ -159,6 +161,16 @@ async function runCodexAppServerTurn({
     turnId = started?.turn?.id || started?.turnId;
     if (!turnId)
       throw new Error("codex app-server turn/start returned no turn id");
+    if (noWait) {
+      return {
+        status: "submitted",
+        inputSent: true,
+        done: false,
+        turnId,
+        submittedAt: new Date().toISOString(),
+        target: threadId,
+      };
+    }
     for (const [kind, params] of pending) receive(kind, params);
     const result = await completion;
     const entries = [...messages.values()].map((item) => ({
@@ -264,6 +276,30 @@ export async function listCodexAppServerThreads({
   }
 }
 
+export async function renameCodexAppServerThread({
+  socketPath,
+  threadId,
+  name,
+  clientFactory = (opts) => new JsonRpcWsUdsClient(opts),
+} = {}) {
+  const timeoutMs = DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS;
+  const client = codexClient(socketPath, timeoutMs, clientFactory);
+  try {
+    await initializeCodexClient(client, timeoutMs);
+    await client.request("thread/name/set", { threadId, name }, timeoutMs);
+    return {
+      ok: true,
+      cli: "codex",
+      transport: "uds",
+      threadId,
+      name,
+      nameApplied: true,
+    };
+  } finally {
+    client.close();
+  }
+}
+
 export async function askCodexAppServerThread({
   socketPath,
   threadId,
@@ -274,6 +310,9 @@ export async function askCodexAppServerThread({
   ifBusy = "wait",
   busyTimeoutMs = timeoutMs,
   pollIntervalMs = 200,
+  noWait = false,
+  warnContextPct,
+  maxContextPct,
   clientFactory = (opts) => new JsonRpcWsUdsClient(opts),
 } = {}) {
   if (typeof prompt !== "string" || !prompt.trim())
@@ -353,6 +392,24 @@ export async function askCodexAppServerThread({
       { threadId: selectedId, excludeTurns: true },
       DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
     );
+    const context = await readCodexContext(
+      resumed?.thread?.path || thread.path,
+      selectedId,
+    );
+    const guard = contextGuard("codex", context, {
+      warnContextPct,
+      maxContextPct,
+    });
+    if (guard.ok === false) {
+      return {
+        ...guard,
+        status: "failed",
+        done: false,
+        cli: "codex",
+        transport: "uds",
+        threadId: selectedId,
+      };
+    }
     let activeTurns = null;
     if (resumed?.thread?.status?.type === "active")
       activeTurns = resumed.thread.turns?.length
@@ -371,9 +428,13 @@ export async function askCodexAppServerThread({
       timeoutMs,
       maxTurnMs,
       expectedTurnId,
+      noWait,
     });
     if (turn.message) throw new Error(turn.message);
     return {
+      ...turn,
+      ...context,
+      ...guard,
       cli: "codex",
       transport: "uds",
       threadId: selectedId,
@@ -381,7 +442,8 @@ export async function askCodexAppServerThread({
       response: turn.response,
       done: turn.status === "completed",
       matchedCompletion: turn.matchedCompletion,
-      timedOut: turn.timedOut,
+      ...(noWait ? {} : { timedOut: turn.timedOut }),
+      ...(noWait ? { ok: true } : {}),
       status: turn.status,
       commentary: turn.commentary,
       meta: { retries: turn.retries },

package/hub/team/worktree-lifecycle.mjs

@@ -1,5 +1,4 @@
 // hub/team/worktree-lifecycle.mjs — Git worktree lifecycle management
-// Replaces shell commands in tfx-codex-swarm Step 5 + merge-worktree Phase 6.
 // Convention: .codex-swarm/wt-{slug} paths, swarm/{runId}/{slug} branches.
 // Remote support: host option → SSH-based git operations via remote-session.mjs.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/remote",
-  "version": "10.48.1",
+  "version": "10.50.0",
   "description": "triflux remote — team mode, psmux, MCP workers, SQLite store.",
   "type": "module",
   "main": "hub/index.mjs",
@@ -9,7 +9,7 @@
     "./hub/*": "./hub/*"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20"
   },
   "peerDependencies": {
     "@triflux/core": "^10.0.0-alpha.1"
@@ -20,7 +20,6 @@
     "better-sqlite3": "^12.10.0",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
-    "systray2": "^2.1.4",
     "zod": "^4.0.0"
   },
   "files": [

package/scripts/lib/doctor-env-checks.mjs

@@ -34,88 +34,3 @@ export function inspectMacTimeoutDependency({
     fix: "brew install coreutils",
   };
 }
-
-export function addPluginRootFallbackToCommand(command, pluginRoot) {
-  if (typeof command !== "string") return command;
-  const fallbackRoot = String(pluginRoot || "").replace(/\\/g, "/");
-  if (!fallbackRoot) return command;
-  return command
-    .replaceAll("${PLUGIN_ROOT}", `\${PLUGIN_ROOT:-${fallbackRoot}}`)
-    .replaceAll(
-      "${CLAUDE_PLUGIN_ROOT}",
-      `\${CLAUDE_PLUGIN_ROOT:-${fallbackRoot}}`,
-    )
-    .replace(
-      /(^|[\s"'])\/(hooks|scripts)\//g,
-      `$1\${PLUGIN_ROOT:-${fallbackRoot}}/$2/`,
-    );
-}
-
-function hasBarePluginRootReference(command) {
-  if (typeof command !== "string") return false;
-  return (
-    command.includes("${PLUGIN_ROOT}/") ||
-    command.includes("${CLAUDE_PLUGIN_ROOT}/")
-  );
-}
-
-function hasCollapsedRootHookPath(command) {
-  if (typeof command !== "string") return false;
-  return /(^|[\s"'])\/(?:hooks|scripts)\//.test(command);
-}
-
-export function findPluginRootHookIssues(settings) {
-  const hooksByEvent =
-    settings?.hooks && typeof settings.hooks === "object" ? settings.hooks : {};
-  const issues = [];
-
-  for (const [event, entries] of Object.entries(hooksByEvent)) {
-    if (!Array.isArray(entries)) continue;
-    for (const entry of entries) {
-      const hooks = Array.isArray(entry?.hooks) ? entry.hooks : [];
-      for (const hook of hooks) {
-        const command = hook?.command;
-        if (
-          !hasBarePluginRootReference(command) &&
-          !hasCollapsedRootHookPath(command)
-        ) {
-          continue;
-        }
-        issues.push({
-          event,
-          matcher: entry?.matcher || "*",
-          command,
-          reason: hasCollapsedRootHookPath(command)
-            ? "collapsed-root-path"
-            : "missing-plugin-root-fallback",
-        });
-      }
-    }
-  }
-
-  return issues;
-}
-
-export function applyPluginRootHookFallbacks(settings, { pluginRoot } = {}) {
-  if (!settings?.hooks || typeof settings.hooks !== "object") {
-    return { changed: false, count: 0, settings };
-  }
-
-  let count = 0;
-  for (const entries of Object.values(settings.hooks)) {
-    if (!Array.isArray(entries)) continue;
-    for (const entry of entries) {
-      const hooks = Array.isArray(entry?.hooks) ? entry.hooks : [];
-      for (const hook of hooks) {
-        if (typeof hook?.command !== "string") continue;
-        const next = addPluginRootFallbackToCommand(hook.command, pluginRoot);
-        if (next !== hook.command) {
-          hook.command = next;
-          count++;
-        }
-      }
-    }
-  }
-
-  return { changed: count > 0, count, settings };
-}

package/scripts/lib/legacy-hook-cleanup.mjs

@@ -0,0 +1,230 @@
+import {
+  constants,
+  copyFileSync,
+  existsSync,
+  lstatSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+// 설치된 Triflux 실행 대상만 식별한다.
+const MANAGED_FILENAMES = [
+  "hook-orchestrator.mjs",
+  "claude-cwd-projection-refresh.mjs",
+  "permission-safe-allow.mjs",
+  "safety-guard.mjs",
+  "pipeline-stop.mjs",
+  "agent-route-guard.mjs",
+  "cross-review-tracker.mjs",
+  "cross-review-gate.mjs",
+  "tfx-gate-activate.mjs",
+  "subagent-tracker.mjs",
+  "subagent-verifier.mjs",
+  "error-context.mjs",
+  "hook-adaptive-collector.mjs",
+  "post-tool-tips.mjs",
+  "pre-compact-snapshot.mjs",
+  "cto-north-star-brief.mjs",
+  "session-start-lake.mjs",
+  "session-start-fast.mjs",
+  "session-end-cleanup.mjs",
+  "mcp-config-watcher.mjs",
+  "keyword-detector.mjs",
+  "setup.mjs",
+  "hub-ensure.mjs",
+  "preflight-cache.mjs",
+  "mcp-gateway-ensure.mjs",
+  "mcp-safety-guard.mjs",
+  "session-stale-cleanup.mjs",
+];
+
+const targetNames = MANAGED_FILENAMES.join("|").replaceAll(".", "\\.");
+const uniqueTargetNames = MANAGED_FILENAMES.filter(
+  (name) =>
+    ![
+      "setup.mjs",
+      "hub-ensure.mjs",
+      "preflight-cache.mjs",
+      "mcp-gateway-ensure.mjs",
+      "mcp-safety-guard.mjs",
+      "session-stale-cleanup.mjs",
+    ].includes(name),
+)
+  .join("|")
+  .replaceAll(".", "\\.");
+const packageTarget = new RegExp(
+  String.raw`[/\\]triflux(?:[/\\](?:\.worktrees[/\\][^/\\]+|v?\d+\.\d+\.\d+[^/\\]*))?[/\\](?:hooks|scripts)[/\\](?:${targetNames})$`,
+);
+const pluginRootTarget = new RegExp(
+  String.raw`^\$\{(?:CLAUDE_)?PLUGIN_ROOT\}[/\\](?:hooks|scripts)[/\\](?:${uniqueTargetNames})$`,
+);
+const gateSuffix = ".claude/scripts/tfx-gate-activate.mjs";
+
+function isInstalledGateTarget(target) {
+  const normalized = target.replaceAll("\\", "/");
+  if (
+    ["${HOME}", "$HOME", "~"].some(
+      (root) => normalized === `${root}/${gateSuffix}`,
+    )
+  )
+    return true;
+  const installedTargets = [join(homedir(), gateSuffix)];
+  if (process.env.CLAUDE_CONFIG_DIR)
+    installedTargets.push(
+      join(process.env.CLAUDE_CONFIG_DIR, "scripts/tfx-gate-activate.mjs"),
+    );
+  return installedTargets.some(
+    (installed) => normalized === installed.replaceAll("\\", "/"),
+  );
+}
+
+function readCommandToken(command) {
+  const match = command.match(/^\s*(?:"([^"]*)"|'([^']*)'|(\S+))(.*)$/s);
+  return match
+    ? { value: match[1] ?? match[2] ?? match[3], rest: match[4] }
+    : null;
+}
+
+function matchesTarget(target) {
+  const resolvedFallback = target.replace(
+    /^\$\{(?:CLAUDE_)?PLUGIN_ROOT:-([^}]+)\}/,
+    "$1",
+  );
+  return (
+    packageTarget.test(resolvedFallback) ||
+    pluginRootTarget.test(target) ||
+    isInstalledGateTarget(target)
+  );
+}
+
+export function isLegacyTrifluxHook(hook) {
+  if (hook?.type !== "command" || typeof hook.command !== "string")
+    return false;
+  const command = hook.command;
+  const executable = readCommandToken(command);
+  if (!executable || !/(?:^|[/\\])node(?:\.exe)?$/.test(executable.value))
+    return false;
+  const target = readCommandToken(executable.rest);
+  if (!target) return false;
+  // 옛 inline bootstrap만 제거한다.
+  if (target.value === "-e" || target.value === "--eval")
+    return (
+      command.includes(".tfx-pkg-root") &&
+      command.includes("hook-orchestrator.mjs") &&
+      command.includes("spawnSync") &&
+      command.includes("path.join(root")
+    );
+  if (matchesTarget(target.value)) return true;
+  // run.cjs의 keyword-detector 인자를 확인한다.
+  if (/[/\\]scripts[/\\]run\.cjs$/.test(target.value)) {
+    const script = readCommandToken(target.rest);
+    return (
+      script?.value.endsWith("/scripts/keyword-detector.mjs") &&
+      (matchesTarget(script.value) || pluginRootTarget.test(script.value))
+    );
+  }
+  return false;
+}
+
+function removeManagedHooks(settings) {
+  let removed = 0;
+  const events = settings?.hooks;
+  if (!events || typeof events !== "object" || Array.isArray(events))
+    return removed;
+  for (const [event, entries] of Object.entries(events)) {
+    if (!Array.isArray(entries)) continue;
+    const kept = [];
+    for (const entry of entries) {
+      if (!Array.isArray(entry?.hooks)) {
+        kept.push(entry);
+        continue;
+      }
+      const hooks = entry.hooks.filter((hook) => {
+        if (!isLegacyTrifluxHook(hook)) return true;
+        removed++;
+        return false;
+      });
+      if (hooks.length)
+        kept.push(
+          hooks.length === entry.hooks.length ? entry : { ...entry, hooks },
+        );
+    }
+    if (kept.length) events[event] = kept;
+    else delete events[event];
+  }
+  if (Object.keys(events).length === 0) delete settings.hooks;
+  return removed;
+}
+
+/** Claude 설정의 이전 Triflux command hook을 정리한다. */
+export function cleanupLegacyHooks({
+  settingsPath = join(
+    process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude"),
+    "settings.json",
+  ),
+  dryRun = false,
+} = {}) {
+  const result = {
+    ok: true,
+    changed: false,
+    wouldChange: false,
+    removed: 0,
+    backupPath: null,
+    error: null,
+  };
+  let original;
+  let settings;
+  try {
+    const pathInfo = lstatSync(settingsPath, { throwIfNoEntry: false });
+    if (!pathInfo) return result;
+    // symlink는 유지하고 실제 파일을 교체한다.
+    const targetPath = pathInfo.isSymbolicLink()
+      ? realpathSync(settingsPath)
+      : settingsPath;
+    original = readFileSync(targetPath, "utf8");
+    settings = JSON.parse(original);
+    if (!settings || typeof settings !== "object" || Array.isArray(settings))
+      throw new Error("settings.json must contain an object");
+    result.removed = removeManagedHooks(settings);
+    result.wouldChange = result.removed > 0;
+    if (!result.wouldChange || dryRun) return result;
+
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    let backupPath = `${settingsPath}.tfx-bak-${stamp}`;
+    for (let suffix = 1; existsSync(backupPath); suffix++)
+      backupPath = `${settingsPath}.tfx-bak-${stamp}-${suffix}`;
+    copyFileSync(settingsPath, backupPath, constants.COPYFILE_EXCL);
+    result.backupPath = backupPath;
+
+    const temporary = join(
+      dirname(targetPath),
+      `.settings.json.tfx-${process.pid}-${Date.now()}.tmp`,
+    );
+    try {
+      writeFileSync(temporary, `${JSON.stringify(settings, null, 2)}\n`, {
+        encoding: "utf8",
+        flag: "wx",
+        mode: statSync(targetPath).mode,
+      });
+      renameSync(temporary, targetPath);
+    } catch (error) {
+      try {
+        unlinkSync(temporary);
+      } catch {
+        /* 임시 파일 없음 */
+      }
+      throw error;
+    }
+    result.changed = true;
+  } catch (error) {
+    result.ok = false;
+    result.error = error.message;
+  }
+  return result;
+}