triflux 10.20.0 → 10.20.2

package/hooks/hooks.json

@@ -25,6 +25,18 @@
         ]
       }
     ],
+    "PermissionRequest": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/hook-orchestrator.mjs\"",
+            "timeout": 3
+          }
+        ]
+      }
+    ],
     "PreToolUse": [
       {
         "matcher": "Bash|Agent|Skill",
@@ -39,7 +51,7 @@
     ],
     "PostToolUse": [
       {
-        "matcher": "Edit|Write",
+        "matcher": "Bash|Edit|Write",
         "hooks": [
           {
             "type": "command",
@@ -73,6 +85,30 @@
         ]
       }
     ],
+    "SessionEnd": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/hook-orchestrator.mjs\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "SubagentStart": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/hook-orchestrator.mjs\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
     "SubagentStop": [
       {
         "matcher": "*",
@@ -84,6 +120,18 @@
           }
         ]
       }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/hook-orchestrator.mjs\"",
+            "timeout": 5
+          }
+        ]
+      }
     ]
   }
 }

package/hooks/permission-safe-allow.mjs

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+
+import { stdin, stdout } from "node:process";
+
+const META_PATTERNS = [/&&/, /\|\|/, /[;|<>`]/, /\$\(/];
+const RISKY_PATTERNS = [
+  /(^|\s)rm(\s|$)/,
+  /(^|\s)mv(\s|$)/,
+  /(^|\s)cp(\s|$)/,
+  /(^|\s)curl(\s|$)/,
+  /(^|\s)wget(\s|$)/,
+  /(^|\s)sudo(\s|$)/,
+  /(^|\s)chmod(\s|$)/,
+  /(^|\s)chown(\s|$)/,
+  /(^|\s)git\s+push(\s|$)/,
+  /(^|\s)git\s+reset(\s|$)/,
+  /(^|\s)git\s+clean(\s|$)/,
+  /(^|\s)npm\s+publish(\s|$)/,
+  /(^|\s)pnpm\s+publish(\s|$)/,
+  /(^|\s)yarn\s+publish(\s|$)/,
+];
+
+function silentlyExit() {
+  process.exit(0);
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let input = "";
+    stdin.setEncoding("utf8");
+    stdin.on("data", (chunk) => {
+      input += chunk;
+    });
+    stdin.on("end", () => resolve(input));
+    stdin.resume();
+  });
+}
+
+function shellWords(command) {
+  const words = [];
+  const pattern = /"([^"]*)"|'([^']*)'|([^\s]+)/g;
+  let match;
+  while ((match = pattern.exec(command)) !== null) {
+    words.push(match[1] ?? match[2] ?? match[3]);
+  }
+  return words;
+}
+
+function isRepoRelativePath(value) {
+  if (!value || value.startsWith("/") || value.startsWith("~")) return false;
+  if (value === ".") return true;
+  if (value === ".." || value.startsWith("../") || value.includes("/../"))
+    return false;
+  return /^[A-Za-z0-9._/*?@{}+,:=-][A-Za-z0-9._/*?'@{}+,:=-]*$/.test(value);
+}
+
+function hasUnsafeSurface(command) {
+  return (
+    META_PATTERNS.some((pattern) => pattern.test(command)) ||
+    RISKY_PATTERNS.some((pattern) => pattern.test(command))
+  );
+}
+
+function allowGit(words, command) {
+  if (command === "git status" || command === "git status --short")
+    return "git status";
+  if (command === "git diff --stat" || command === "git diff --cached --stat")
+    return "git diff stat";
+  if (command === "git branch --show-current") return "git branch";
+  if (words[0] === "git" && words[1] === "log" && words[2] === "--oneline") {
+    const rest = words.slice(3);
+    if (
+      rest.every(
+        (word) =>
+          /^[A-Za-z0-9._/@{}~^:+,=-]+$/.test(word) && !word.startsWith("-"),
+      )
+    ) {
+      return "git log";
+    }
+  }
+  return null;
+}
+
+function allowListing(words) {
+  if (words[0] === "pwd" && words.length === 1) return "pwd";
+
+  if (words[0] === "ls") {
+    const args = words.slice(1);
+    if (
+      args.every(
+        (word) => /^-[A-Za-z0-9]+$/.test(word) || isRepoRelativePath(word),
+      )
+    ) {
+      return "ls";
+    }
+  }
+
+  if (words[0] === "find") {
+    const args = words.slice(1);
+    if (args.some((word) => word === "-delete" || word.startsWith("-exec")))
+      return null;
+    const firstOption = args.findIndex((word) => word.startsWith("-"));
+    const pathArgs = (
+      firstOption === -1 ? args : args.slice(0, firstOption)
+    ).filter(Boolean);
+    if (pathArgs.length === 0 || pathArgs.every(isRepoRelativePath)) {
+      return "find";
+    }
+  }
+
+  return null;
+}
+
+function allowSearch(words) {
+  if (words[0] !== "rg" && words[0] !== "grep") return null;
+  const args = words.slice(1);
+  if (args.length === 0) return null;
+  if (
+    args.some(
+      (word) =>
+        word.startsWith("/") ||
+        word === ".." ||
+        word.startsWith("../") ||
+        word.includes("/../"),
+    )
+  ) {
+    return null;
+  }
+  return `${words[0]} search`;
+}
+
+function allowTargetedTest(words) {
+  if (words[0] !== "node" || words[1] !== "scripts/test-lock.mjs") return null;
+  if (!words.includes("--test")) return null;
+  const args = words.slice(2);
+  const allowedFlags = new Set(["--test", "--test-force-exit"]);
+  const pathArgs = [];
+  for (const word of args) {
+    if (allowedFlags.has(word)) continue;
+    if (/^--test-concurrency=\d+$/.test(word)) continue;
+    if (word.startsWith("-")) return null;
+    pathArgs.push(word);
+  }
+  if (pathArgs.length === 0) return null;
+  if (
+    pathArgs.every(
+      (word) =>
+        word.startsWith("tests/") || word.startsWith("scripts/__tests__/"),
+    ) &&
+    pathArgs.every(isRepoRelativePath)
+  ) {
+    return "targeted test";
+  }
+  return null;
+}
+
+function allowNpm(command) {
+  // npm scripts are intentionally not auto-allowed: package.json can redefine
+  // them to perform arbitrary side effects. Prefer explicit node test commands.
+  void command;
+  return null;
+}
+
+function allowanceReason(command) {
+  const trimmed = command.trim().replace(/\s+/g, " ");
+  if (!trimmed || hasUnsafeSurface(trimmed)) return null;
+
+  const words = shellWords(trimmed);
+  if (words.length === 0) return null;
+
+  return (
+    allowGit(words, trimmed) ??
+    allowListing(words) ??
+    allowSearch(words) ??
+    allowTargetedTest(words) ??
+    allowNpm(trimmed)
+  );
+}
+
+function hasAskSuggestion(value) {
+  if (!value || typeof value !== "object") return false;
+  if (Array.isArray(value)) return value.some(hasAskSuggestion);
+  if (value.behavior === "ask") return true;
+  if (value.decision?.behavior === "ask") return true;
+  return Object.values(value).some(hasAskSuggestion);
+}
+
+function emitAllow(reason) {
+  stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PermissionRequest",
+        decision: { behavior: "allow" },
+        additionalContext: `[permission-safe-allow] allowed: ${reason}`,
+      },
+    }),
+  );
+}
+
+const input = await readStdin();
+let payload;
+try {
+  payload = JSON.parse(input || "{}");
+} catch {
+  silentlyExit();
+}
+
+if (
+  payload?.hook_event_name !== "PermissionRequest" ||
+  payload?.tool_name !== "Bash"
+) {
+  silentlyExit();
+}
+
+if (
+  hasAskSuggestion(
+    payload.permission_suggestions ?? payload.permissionSuggestions,
+  )
+) {
+  silentlyExit();
+}
+
+const command = payload?.tool_input?.command ?? payload?.command;
+if (typeof command !== "string") {
+  silentlyExit();
+}
+
+const reason = allowanceReason(command);
+if (!reason) {
+  silentlyExit();
+}
+
+emitAllow(reason);

package/hooks/pipeline-stop.mjs

@@ -1,11 +1,24 @@
 #!/usr/bin/env node
-// hooks/pipeline-stop.mjs — Stop 훅: 활성 파이프라인 감지 시 구조화 decision 반환
+// hooks/pipeline-stop.mjs — Stop 훅: 컨텍스트 가드와 활성 파이프라인 감지
 //
 // Claude Code Stop 이벤트에서 실행.
-// 비터미널 단계의 파이프라인이 있으면 decision:"block" + reason으로 중단을 방지한다.
-// 파이프라인이 없으면 정상 종료를 허용한다.
+// 컨텍스트 한계/사용자 중단 신호는 조용히 통과시키고, 높은 컨텍스트 사용량은
+// 세션별 제한 횟수만 block 한다. 이후 비터미널 단계의 파이프라인이 있으면
+// decision:"block" + reason으로 중단을 방지한다.
 
-import { existsSync } from "node:fs";
+import { createHash } from "node:crypto";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  readSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 let getPipelineStateDbPath;
 let ensurePipelineTable;
@@ -22,6 +35,319 @@ const PROJECT_ROOT = process.env.CLAUDE_CWD || process.cwd();
 const HUB_DB_PATH = getPipelineStateDbPath(PROJECT_ROOT);
 const TERMINAL = new Set(["complete", "failed"]);
 
+const DEFAULT_CONTEXT_THRESHOLD = 75;
+const DEFAULT_CRITICAL_THRESHOLD = 95;
+const DEFAULT_MAX_BLOCKS = 2;
+const SESSION_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,255}$/;
+
+const CONTEXT_LIMIT_PATTERNS = [
+  "context_limit",
+  "context_window",
+  "context_exceeded",
+  "context_full",
+  "max_context",
+  "token_limit",
+  "max_tokens",
+  "conversation_too_long",
+  "input_too_long",
+];
+const USER_ABORT_EXACT = new Set([
+  "aborted",
+  "abort",
+  "cancel",
+  "cancelled",
+  "interrupt",
+]);
+const USER_ABORT_SUBSTRINGS = [
+  "user_cancel",
+  "user_interrupt",
+  "ctrl_c",
+  "manual_stop",
+  "keyboard_interrupt",
+];
+
+function readStopPayload() {
+  try {
+    const raw = readFileSync(0, "utf8");
+    if (!raw.trim()) return {};
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function envNumber(name, fallback) {
+  const value = Number(process.env[name]);
+  return Number.isFinite(value) ? value : fallback;
+}
+
+function stopReason(payload) {
+  return String(
+    payload.stop_reason ??
+      payload.stopReason ??
+      payload.reason ??
+      payload.error ??
+      "",
+  ).toLowerCase();
+}
+
+function isContextLimitStop(payload) {
+  const reason = stopReason(payload);
+  return CONTEXT_LIMIT_PATTERNS.some((pattern) => reason.includes(pattern));
+}
+
+function isUserAbortStop(payload) {
+  if (payload.user_requested === true || payload.userRequested === true) {
+    return true;
+  }
+
+  const reason = stopReason(payload).trim();
+  return (
+    USER_ABORT_EXACT.has(reason) ||
+    USER_ABORT_SUBSTRINGS.some((pattern) => reason.includes(pattern))
+  );
+}
+
+function numericPercent(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number >= 0 ? number : null;
+}
+
+function tokenPercent(used, max) {
+  const usedNumber = Number(used);
+  const maxNumber = Number(max);
+  if (
+    !Number.isFinite(usedNumber) ||
+    !Number.isFinite(maxNumber) ||
+    maxNumber <= 0
+  ) {
+    return null;
+  }
+  return (usedNumber / maxNumber) * 100;
+}
+
+function contextPercentsFromObject(value) {
+  if (!value || typeof value !== "object") return [];
+
+  const candidates = [
+    value.used_percentage,
+    value.usedPercentage,
+    value.used_percent,
+    value.usedPercent,
+    value.percentage,
+    value.percent,
+    value.context_percent,
+    value.contextPercent,
+  ];
+
+  const currentUsage = value.current_usage ?? value.currentUsage ?? {};
+  const maxTokens =
+    value.context_window_size ??
+    value.contextWindowSize ??
+    value.max_context_tokens ??
+    value.maxContextTokens ??
+    value.max_tokens ??
+    value.maxTokens ??
+    value.total_tokens ??
+    value.totalTokens;
+  candidates.push(
+    tokenPercent(value.used_tokens ?? value.usedTokens, maxTokens),
+    tokenPercent(
+      currentUsage.input_tokens ?? currentUsage.inputTokens,
+      maxTokens,
+    ),
+    tokenPercent(
+      currentUsage.total_tokens ?? currentUsage.totalTokens,
+      maxTokens,
+    ),
+  );
+
+  return candidates.map(numericPercent).filter((percent) => percent !== null);
+}
+
+function contextPercentFromPayload(payload) {
+  const percents = [
+    ...contextPercentsFromObject(payload.context_window),
+    ...contextPercentsFromObject(payload.contextWindow),
+  ];
+  return percents.length > 0 ? Math.max(...percents) : null;
+}
+
+function parseJsonCandidate(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function readTranscriptTail(transcriptPath) {
+  let fd;
+  try {
+    const stat = statSync(transcriptPath);
+    if (!stat.isFile()) return null;
+
+    const bytesToRead = Math.min(stat.size, 64 * 1024);
+    const offset = Math.max(0, stat.size - bytesToRead);
+    const buffer = Buffer.alloc(bytesToRead);
+
+    fd = openSync(transcriptPath, "r");
+    const bytesRead = readSync(fd, buffer, 0, bytesToRead, offset);
+    return buffer.toString("utf8", 0, bytesRead);
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) {
+      try {
+        closeSync(fd);
+      } catch {
+        // Ignore close failures: transcript reads are best-effort only.
+      }
+    }
+  }
+}
+
+function contextPercentFromTranscript(payload) {
+  const transcriptPath = payload.transcript_path ?? payload.transcriptPath;
+  if (!transcriptPath || typeof transcriptPath !== "string") return null;
+
+  const tail = readTranscriptTail(transcriptPath);
+  if (tail === null) return 0;
+
+  const percents = [];
+  for (const line of tail.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parsed = parseJsonCandidate(trimmed);
+    if (!parsed) continue;
+    const percent = contextPercentFromPayload(parsed);
+    if (percent !== null) percents.push(percent);
+  }
+  return percents.length > 0 ? Math.max(...percents) : null;
+}
+
+function contextPercentFromCache() {
+  const home = process.env.HOME || process.env.USERPROFILE;
+  if (!home) return null;
+  const cachePath = join(
+    home,
+    ".claude",
+    "cache",
+    "tfx-hub",
+    "context-monitor.json",
+  );
+  if (!existsSync(cachePath)) return null;
+
+  try {
+    const parsed = parseJsonCandidate(readFileSync(cachePath, "utf8"));
+    if (!parsed) return null;
+    const direct = contextPercentFromPayload(parsed);
+    if (direct !== null) return direct;
+    const percents = contextPercentsFromObject(parsed);
+    return percents.length > 0 ? Math.max(...percents) : null;
+  } catch {
+    return null;
+  }
+}
+
+function contextPercent(payload) {
+  return (
+    contextPercentFromPayload(payload) ??
+    contextPercentFromTranscript(payload) ??
+    contextPercentFromCache()
+  );
+}
+
+function guardKey(payload) {
+  const sessionId = payload.session_id ?? payload.sessionId;
+  if (typeof sessionId === "string" && SESSION_ID_PATTERN.test(sessionId)) {
+    return sessionId;
+  }
+
+  const fallback = JSON.stringify({
+    cwd: PROJECT_ROOT,
+    transcript: payload.transcript_path ?? payload.transcriptPath ?? "",
+  });
+  return createHash("sha256").update(fallback).digest("hex");
+}
+
+function stateDir() {
+  return (
+    process.env.TRIFLUX_CONTEXT_GUARD_STATE_DIR ||
+    join(tmpdir(), "tfx-context-guard-stop")
+  );
+}
+
+function statePathForKey(key) {
+  const safeKey = SESSION_ID_PATTERN.test(key)
+    ? key
+    : createHash("sha256").update(key).digest("hex");
+  return join(stateDir(), `${safeKey}.json`);
+}
+
+function readGuardState(path) {
+  try {
+    const parsed = parseJsonCandidate(readFileSync(path, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function maybeContextGuardBlock(payload) {
+  const percent = contextPercent(payload);
+  if (percent === null) return null;
+
+  const threshold = envNumber(
+    "TFX_CONTEXT_GUARD_THRESHOLD",
+    DEFAULT_CONTEXT_THRESHOLD,
+  );
+  const criticalThreshold = envNumber(
+    "TFX_CONTEXT_GUARD_CRITICAL_THRESHOLD",
+    DEFAULT_CRITICAL_THRESHOLD,
+  );
+  const maxBlocks = Math.max(
+    0,
+    Math.floor(envNumber("TFX_CONTEXT_GUARD_MAX_BLOCKS", DEFAULT_MAX_BLOCKS)),
+  );
+
+  if (percent >= criticalThreshold) return null;
+  if (percent < threshold || maxBlocks === 0) return null;
+
+  try {
+    const path = statePathForKey(guardKey(payload));
+    const state = readGuardState(path);
+    const blockCount = Math.max(0, Math.floor(Number(state.blockCount) || 0));
+    if (blockCount >= maxBlocks) return null;
+
+    const nextBlockCount = blockCount + 1;
+    mkdirSync(stateDir(), { recursive: true });
+    writeFileSync(
+      path,
+      JSON.stringify({
+        blockCount: nextBlockCount,
+        percent,
+        updatedAt: new Date().toISOString(),
+      }),
+      "utf8",
+    );
+
+    return {
+      decision: "block",
+      reason:
+        `[tfx context guard] context usage ${percent.toFixed(1)}% is above ` +
+        `${threshold}% threshold. Compact or reduce context before stopping. ` +
+        `(Block ${nextBlockCount}/${maxBlocks})`,
+    };
+  } catch {
+    // Context guard state is best-effort. If retry-state I/O fails, fail open
+    // for the guard only so active pipeline Stop blocks can still run.
+    return null;
+  }
+}
+
 async function checkActivePipelines() {
   if (!existsSync(HUB_DB_PATH)) return [];
 
@@ -39,15 +365,7 @@ async function checkActivePipelines() {
   }
 }
 
-try {
-  const active = await checkActivePipelines();
-
-  if (active.length === 0) {
-    // 활성 파이프라인 없음 → 정상 종료 허용
-    process.exit(0);
-  }
-
-  // 활성 파이프라인 발견 → 구조화 decision으로 block
+function activePipelineBlock(active) {
   const lines = active.map(
     (s) =>
       `  - 팀 ${s.team_name}: ${s.phase} 단계 (fix: ${s.fix_attempt}/${s.fix_max}, ralph: ${s.ralph_iteration}/${s.ralph_max})`,
@@ -60,13 +378,34 @@ try {
     `파이프라인을 이어서 진행하려면 /tfx-multi status 로 상태를 확인하세요.\n` +
     `강제 종료하려면 /tfx-multi cancel 을 먼저 실행하세요.`;
 
-  // 구조화된 Stop hook 출력: decision + reason
-  const output = {
+  return {
     decision: "block",
     reason,
   };
+}
 
-  process.stdout.write(JSON.stringify(output));
+try {
+  const payload = readStopPayload();
+
+  if (isContextLimitStop(payload) || isUserAbortStop(payload)) {
+    process.exit(0);
+  }
+
+  const contextBlock = maybeContextGuardBlock(payload);
+  if (contextBlock) {
+    process.stdout.write(JSON.stringify(contextBlock));
+    process.exit(0);
+  }
+
+  const active = await checkActivePipelines();
+
+  if (active.length === 0) {
+    // 활성 파이프라인 없음 → 정상 종료 허용
+    process.exit(0);
+  }
+
+  // 활성 파이프라인 발견 → 구조화 decision으로 block
+  process.stdout.write(JSON.stringify(activePipelineBlock(active)));
 } catch {
   // 훅 실패 시 종료 허용
   process.exit(0);