@triflux/remote 10.49.0 → 10.50.0

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.49.0",
+  "version": "10.50.0",
   "description": "triflux remote — team mode, psmux, MCP workers, SQLite store.",
   "type": "module",
   "main": "hub/index.mjs",

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;
+}