triflux 10.0.0 → 10.0.2

package/scripts/lib/claudemd-scanner.mjs

@@ -0,0 +1,218 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const TFX_START = "<!-- TFX:START -->";
+export const TFX_END = "<!-- TFX:END -->";
+export const OMC_END = "<!-- OMC:END -->";
+const TFX_VERSION_RE = /<!-- TFX:VERSION:([\d.]+) -->/u;
+
+const LEGACY_PATTERNS = [
+  /<user_cli_routing>/u,
+  /Codex Pro 무료 기간/u,
+  /codex exec --dangerously-bypass.*skip-git-repo-check/u,
+  /OMC 에이전트 → CLI 매핑/u,
+  /Spark 가드레일/u,
+];
+
+const DEFAULT_TFX_TEMPLATE = [
+  "### triflux CLI routing (managed)",
+  "- 이 블록은 triflux setup에서 자동으로 관리됩니다.",
+  "- 직접 수정이 필요하면 블록 바깥에 사용자 섹션을 추가하세요.",
+].join("\n");
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_TEMPLATE_PATH = join(SCRIPT_DIR, "..", "templates", "claudemd-tfx-section.md");
+
+function resolveVersion(version) {
+  if (version) return version;
+  try {
+    const pkgPath = join(SCRIPT_DIR, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+function resolveTemplate(template, templatePath = DEFAULT_TEMPLATE_PATH) {
+  if (typeof template === "string" && template.trim()) {
+    return template.trim();
+  }
+  if (existsSync(templatePath)) {
+    const raw = readFileSync(templatePath, "utf8").trim();
+    if (raw) return raw;
+  }
+  return DEFAULT_TFX_TEMPLATE;
+}
+
+function findManagedSection(rawText) {
+  const raw = String(rawText || "");
+  const startIdx = raw.indexOf(TFX_START);
+  const endMarkerIdx = raw.indexOf(TFX_END);
+  if (startIdx === -1 || endMarkerIdx === -1 || endMarkerIdx <= startIdx) {
+    return {
+      found: false,
+      content: null,
+      version: null,
+      startIdx: -1,
+      endIdx: -1,
+    };
+  }
+
+  const endIdx = endMarkerIdx + TFX_END.length;
+  const content = raw.slice(startIdx, endIdx);
+  const versionMatch = content.match(TFX_VERSION_RE);
+
+  return {
+    found: true,
+    content,
+    version: versionMatch ? versionMatch[1] : null,
+    startIdx,
+    endIdx,
+  };
+}
+
+function detectLegacyRange(rawText) {
+  const raw = String(rawText || "");
+  const matches = LEGACY_PATTERNS.some((pattern) => pattern.test(raw));
+  if (!matches) {
+    return { found: false, startIdx: -1, endIdx: -1 };
+  }
+
+  const startTag = raw.indexOf("<user_cli_routing>");
+  const endTag = raw.indexOf("</user_cli_routing>");
+  if (startTag === -1 || endTag === -1 || endTag <= startTag) {
+    return { found: true, startIdx: -1, endIdx: -1 };
+  }
+
+  let removeStart = startTag;
+  const userOverridesComment = "<!-- USER OVERRIDES";
+  const commentIdx = raw.lastIndexOf(userOverridesComment, startTag);
+  if (commentIdx !== -1 && startTag - commentIdx < 200) {
+    removeStart = commentIdx;
+  }
+
+  return {
+    found: true,
+    startIdx: removeStart,
+    endIdx: endTag + "</user_cli_routing>".length,
+  };
+}
+
+function normalizeSpacing(text) {
+  return String(text || "").replace(/\n{3,}/gu, "\n\n");
+}
+
+export function findAllClaudeMdPaths(options = {}) {
+  const cwd = options.cwd ? resolve(options.cwd) : process.cwd();
+  const homeDir = options.homeDir ? resolve(options.homeDir) : homedir();
+  const includeGlobal = options.includeGlobal !== false;
+  const includeProject = options.includeProject !== false;
+
+  const candidates = [];
+  if (includeGlobal) candidates.push(join(homeDir, ".claude", "CLAUDE.md"));
+  if (includeProject) candidates.push(join(cwd, "CLAUDE.md"));
+
+  const seen = new Set();
+  const paths = [];
+  for (const candidate of candidates) {
+    const normalized = resolve(candidate);
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    if (existsSync(normalized)) {
+      paths.push(normalized);
+    }
+  }
+  return paths;
+}
+
+export function writeSection(filePath, options = {}) {
+  const absolutePath = resolve(filePath);
+  const version = resolveVersion(options.version);
+  const template = resolveTemplate(options.template, options.templatePath);
+  const block = [
+    TFX_START,
+    `<!-- TFX:VERSION:${version} -->`,
+    template,
+    TFX_END,
+  ].join("\n");
+
+  if (!existsSync(absolutePath)) {
+    writeFileSync(absolutePath, `${block}\n`, "utf8");
+    return { action: "created", version, path: absolutePath };
+  }
+
+  const raw = readFileSync(absolutePath, "utf8");
+  const existing = findManagedSection(raw);
+
+  if (existing.found) {
+    const nextContent = `${raw.slice(0, existing.startIdx)}${block}${raw.slice(existing.endIdx)}`;
+    writeFileSync(absolutePath, nextContent, "utf8");
+    return {
+      action: "updated",
+      oldVersion: existing.version,
+      version,
+      path: absolutePath,
+    };
+  }
+
+  const omcEndIdx = raw.indexOf(OMC_END);
+  if (omcEndIdx !== -1) {
+    const insertAt = omcEndIdx + OMC_END.length;
+    const before = raw.slice(0, insertAt);
+    const after = raw.slice(insertAt);
+    const nextContent = `${before}\n${block}${after}`;
+    writeFileSync(absolutePath, nextContent, "utf8");
+    return { action: "inserted_after_omc", version, path: absolutePath };
+  }
+
+  const separator = raw.endsWith("\n") ? "" : "\n";
+  writeFileSync(absolutePath, `${raw}${separator}${block}\n`, "utf8");
+  return { action: "appended", version, path: absolutePath };
+}
+
+export function migrateClaudeMd(filePath, options = {}) {
+  const absolutePath = resolve(filePath);
+  if (!existsSync(absolutePath)) {
+    return { action: "no_file", removed: [], path: absolutePath };
+  }
+
+  const raw = readFileSync(absolutePath, "utf8");
+  const existing = findManagedSection(raw);
+  const legacy = detectLegacyRange(raw);
+
+  if (existing.found && !legacy.found) {
+    return {
+      action: "already_managed",
+      removed: [],
+      version: existing.version,
+      path: absolutePath,
+    };
+  }
+
+  const removed = [];
+  let nextContent = raw;
+
+  if (legacy.found && legacy.startIdx !== -1 && legacy.endIdx !== -1) {
+    nextContent = `${nextContent.slice(0, legacy.startIdx)}${nextContent.slice(legacy.endIdx)}`;
+    removed.push("<user_cli_routing> block");
+  }
+
+  const existingAfterLegacy = findManagedSection(nextContent);
+  if (existingAfterLegacy.found) {
+    nextContent = `${nextContent.slice(0, existingAfterLegacy.startIdx)}${nextContent.slice(existingAfterLegacy.endIdx)}`;
+    removed.push("old TFX block");
+  }
+
+  writeFileSync(absolutePath, normalizeSpacing(nextContent), "utf8");
+  const writeResult = writeSection(absolutePath, options);
+
+  return {
+    action: "migrated",
+    removed,
+    version: writeResult.version,
+    path: absolutePath,
+  };
+}

package/scripts/lib/context.mjs

@@ -0,0 +1,67 @@
+/**
+ * 요청별 로그 컨텍스트 전파 (AsyncLocalStorage 기반).
+ *
+ * Hub HTTP 서버의 요청마다 correlationId를 자동 할당하여,
+ * 하나의 요청에서 발생한 모든 로그를 추적할 수 있다.
+ *
+ * 사용법:
+ *   import { getLogger, getCorrelationId, withRequestContext } from './lib/context.mjs';
+ *
+ *   // 미들웨어에서 컨텍스트 생성
+ *   withRequestContext({ method: 'POST', path: '/bridge/result' }, () => {
+ *     const log = getLogger();
+ *     log.info({ agentId }, 'bridge.result_received');
+ *   });
+ *
+ *   // 내부 함수에서 자동 상관 ID
+ *   function processResult() {
+ *     const log = getLogger();
+ *     log.info('result.processed'); // correlationId 자동 포함
+ *   }
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomUUID } from 'node:crypto';
+
+import { logger } from './logger.mjs';
+
+/** @type {AsyncLocalStorage<{logger: import('pino').Logger, correlationId: string}>} */
+export const asyncLocalStorage = new AsyncLocalStorage();
+
+/**
+ * 현재 요청 컨텍스트의 로거를 반환한다.
+ * 요청 컨텍스트 밖에서 호출하면 기본 로거를 반환한다.
+ *
+ * @returns {import('pino').Logger}
+ */
+export function getLogger() {
+  return asyncLocalStorage.getStore()?.logger || logger;
+}
+
+/**
+ * 현재 요청의 상관 ID를 반환한다.
+ *
+ * @returns {string|undefined}
+ */
+export function getCorrelationId() {
+  return asyncLocalStorage.getStore()?.correlationId;
+}
+
+/**
+ * 요청 컨텍스트를 생성하고 콜백을 실행한다.
+ *
+ * @param {object} context — 컨텍스트 필드 (method, path 등)
+ * @param {string} [context.correlationId] — 외부에서 전달된 상관 ID (없으면 자동 생성)
+ * @param {function} callback — 컨텍스트 내에서 실행할 함수
+ * @returns {*}
+ */
+export function withRequestContext(context, callback) {
+  const correlationId = context.correlationId || randomUUID();
+  const { correlationId: _, ...rest } = context;
+
+  const store = {
+    correlationId,
+    logger: logger.child({ correlationId, ...rest }),
+  };
+
+  return asyncLocalStorage.run(store, callback);
+}

package/scripts/lib/cross-review-utils.mjs

@@ -0,0 +1,51 @@
+import { join } from "node:path";
+
+export const SESSION_TTL_SEC = 30 * 60;
+export const STATE_REL_PATH = join(".omc", "state", "cross-review.json");
+
+export function readStdin() {
+  return new Promise((resolve) => {
+    let raw = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on("end", () => resolve(raw));
+    process.stdin.on("error", () => resolve(""));
+  });
+}
+
+export function parseJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export function nowSec() {
+  return Math.floor(Date.now() / 1000);
+}
+
+export function resolveBaseDir(payload) {
+  if (typeof payload?.cwd === "string" && payload.cwd.trim()) return payload.cwd;
+  if (typeof payload?.directory === "string" && payload.directory.trim()) return payload.directory;
+  return process.cwd();
+}
+
+export function shouldTrackPath(filePath) {
+  if (typeof filePath !== "string" || !filePath.trim()) return false;
+
+  const lower = filePath.toLowerCase();
+  if (lower.startsWith(".omc/") || lower.startsWith(".claude/")) return false;
+  if (lower === "package-lock.json" || lower.endsWith("/package-lock.json")) return false;
+  if (/\.(md|lock|yml|yaml)$/i.test(lower)) return false;
+  return true;
+}
+
+export function expectedReviewer(author) {
+  if (author === "claude") return "codex";
+  if (author === "codex") return "claude";
+  if (author === "gemini") return "claude";
+  return "";
+}

package/scripts/lib/env-probe.mjs

@@ -0,0 +1,241 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { execSync, spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+import { whichCommand, whichCommandAsync } from "../../hub/platform.mjs";
+
+const DEFAULT_STATUS_URL = "http://127.0.0.1:27888/status";
+const _sab = new Int32Array(new SharedArrayBuffer(4));
+const CLI_PROBE_CACHE = new Map();
+const CLI_PROBE_PROMISES = new Map();
+
+const __filename = fileURLToPath(import.meta.url);
+const DEFAULT_PKG_ROOT = join(dirname(__filename), "..", "..");
+
+function sleepSync(ms) {
+  Atomics.wait(_sab, 0, 0, ms);
+}
+
+function fetchHubStatus({
+  execSyncFn = execSync,
+  statusUrl = DEFAULT_STATUS_URL,
+  timeout = 3000,
+} = {}) {
+  const response = execSyncFn(`curl -sf ${statusUrl}`, {
+    timeout,
+    encoding: "utf8",
+    windowsHide: true,
+  });
+  const data = JSON.parse(response);
+  return {
+    ok: true,
+    state: data?.hub?.state || "unknown",
+    pid: data?.pid,
+  };
+}
+
+function normalizeCliName(name) {
+  return String(name ?? "").trim() || null;
+}
+
+function toCliResult(path) {
+  return path ? { ok: true, path } : { ok: false };
+}
+
+function cloneCliResult(result) {
+  return result?.ok ? { ...result } : { ok: false };
+}
+
+function readCachedCliResult(name) {
+  const cached = CLI_PROBE_CACHE.get(name);
+  return cached ? cloneCliResult(cached) : null;
+}
+
+function storeCliResult(name, result) {
+  const snapshot = cloneCliResult(result);
+  CLI_PROBE_CACHE.set(name, snapshot);
+  return cloneCliResult(snapshot);
+}
+
+function buildCliProbeOptions(options = {}) {
+  return {
+    timeout: options.timeout ?? 2000,
+    env: options.env,
+    cwd: options.cwd,
+    platform: options.platform,
+  };
+}
+
+function normalizeCliNames(names) {
+  return [...new Set((names || []).map(normalizeCliName).filter(Boolean))];
+}
+
+function mapCliResults(names, results) {
+  return names.reduce((acc, name, index) => ({
+    ...acc,
+    [name]: results[index],
+  }), {});
+}
+
+async function resolveCliProbe(name, options = {}) {
+  const path = await (options.whichCommandAsyncFn || whichCommandAsync)(name, {
+    ...buildCliProbeOptions(options),
+    execFileFn: options.execFileFn,
+  });
+  return toCliResult(path);
+}
+
+export async function checkCli(name, options = {}) {
+  const cliName = normalizeCliName(name);
+  if (!cliName) return { ok: false };
+
+  const cached = readCachedCliResult(cliName);
+  if (cached) return cached;
+
+  const pending = CLI_PROBE_PROMISES.get(cliName);
+  if (pending) return pending.then(cloneCliResult);
+
+  const nextProbe = resolveCliProbe(cliName, options)
+    .then((result) => storeCliResult(cliName, result))
+    .catch(() => storeCliResult(cliName, { ok: false }))
+    .finally(() => {
+      CLI_PROBE_PROMISES.delete(cliName);
+    });
+
+  CLI_PROBE_PROMISES.set(cliName, nextProbe);
+  return nextProbe.then(cloneCliResult);
+}
+
+export function checkCliSync(name, options = {}) {
+  const cliName = normalizeCliName(name);
+  if (!cliName) return { ok: false };
+
+  const cached = readCachedCliResult(cliName);
+  if (cached) return cached;
+
+  const path = (options.whichCommandFn || whichCommand)(cliName, buildCliProbeOptions(options));
+  return storeCliResult(cliName, toCliResult(path));
+}
+
+export async function probeClis(names, options = {}) {
+  const cliNames = normalizeCliNames(names);
+  const results = await Promise.all(cliNames.map((name) => checkCli(name, options)));
+  return mapCliResults(cliNames, results);
+}
+
+export function resetCliProbeCache() {
+  CLI_PROBE_CACHE.clear();
+  CLI_PROBE_PROMISES.clear();
+}
+
+export function detectCodexAuthState({
+  homeDir = homedir(),
+  existsSyncFn = existsSync,
+  readFileSyncFn = readFileSync,
+} = {}) {
+  try {
+    const authPath = join(homeDir, ".codex", "auth.json");
+    if (!existsSyncFn(authPath)) return { plan: "unknown", source: "no_auth", fingerprint: "no_auth" };
+
+    const auth = JSON.parse(readFileSyncFn(authPath, "utf8"));
+    if (auth.auth_mode !== "chatgpt") {
+      const fingerprint = createHash("sha256")
+        .update(JSON.stringify({
+          auth_mode: auth.auth_mode || "api_key",
+          has_api_key: Boolean(auth.api_key || auth.apiKey),
+        }))
+        .digest("hex");
+      return { plan: "api", source: "api_key", fingerprint };
+    }
+
+    const token = auth.tokens?.id_token || auth.tokens?.access_token;
+    if (!token) {
+      return {
+        plan: "unknown",
+        source: "no_token",
+        fingerprint: createHash("sha256")
+          .update(JSON.stringify({ auth_mode: auth.auth_mode || "chatgpt", token: null }))
+          .digest("hex"),
+      };
+    }
+
+    const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString());
+    const plan = payload?.["https://api.openai.com/auth"]?.chatgpt_plan_type || "unknown";
+    const fingerprint = createHash("sha256")
+      .update(JSON.stringify({
+        auth_mode: auth.auth_mode || "chatgpt",
+        plan,
+        sub: payload?.sub || null,
+        exp: payload?.exp || null,
+      }))
+      .digest("hex");
+    return { plan, source: "jwt", fingerprint };
+  } catch {
+    return { plan: "unknown", source: "error", fingerprint: "error" };
+  }
+}
+
+export function detectCodexPlan(options = {}) {
+  const { plan, source } = detectCodexAuthState(options);
+  return { plan, source };
+}
+
+export function checkHub({
+  pkgRoot = DEFAULT_PKG_ROOT,
+  statusUrl = DEFAULT_STATUS_URL,
+  restart = true,
+  requestTimeoutMs = 3000,
+  pollAttempts = 8,
+  pollIntervalMs = 500,
+  execSyncFn = execSync,
+  spawnFn = spawn,
+  existsSyncFn = existsSync,
+  sleepSyncFn = sleepSync,
+} = {}) {
+  try {
+    return fetchHubStatus({
+      execSyncFn,
+      statusUrl,
+      timeout: requestTimeoutMs,
+    });
+  } catch {}
+
+  if (!restart) return { ok: false, state: "unreachable", restart: "disabled" };
+
+  const serverPath = join(pkgRoot, "hub", "server.mjs");
+  if (!existsSyncFn(serverPath)) return { ok: false, state: "unreachable", restart: "no_server" };
+
+  try {
+    const child = spawnFn(process.execPath, [serverPath], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    child.unref();
+  } catch {
+    return { ok: false, state: "unreachable", restart: "spawn_failed" };
+  }
+
+  for (let i = 0; i < pollAttempts; i++) {
+    sleepSyncFn(pollIntervalMs);
+    try {
+      const status = fetchHubStatus({
+        execSyncFn,
+        statusUrl,
+        timeout: Math.min(requestTimeoutMs, 1000),
+      });
+      if (status.state === "healthy") {
+        return { ...status, restarted: true };
+      }
+    } catch {}
+  }
+
+  return { ok: false, state: "unreachable", restart: "timeout" };
+}
+
+export {
+  DEFAULT_PKG_ROOT,
+  DEFAULT_STATUS_URL,
+};

package/scripts/lib/gemini-profiles.mjs

@@ -0,0 +1,85 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const DEFAULT_GEMINI_PROFILES = {
+  model: "gemini-3.1-pro-preview",
+  profiles: {
+    pro31: { model: "gemini-3.1-pro-preview", hint: "3.1 Pro — 플래그십 (1M ctx, 멀티모달)" },
+    flash3: { model: "gemini-3-flash-preview", hint: "3.0 Flash — 빠른 응답, 비용 효율" },
+    pro25: { model: "gemini-2.5-pro", hint: "2.5 Pro — 안정 (추론 강화)" },
+    flash25: { model: "gemini-2.5-flash", hint: "2.5 Flash — 경량 범용" },
+    lite25: { model: "gemini-2.5-flash-lite", hint: "2.5 Flash Lite — 최경량" },
+  },
+};
+
+const DEFAULT_PROFILE_COUNT = Object.keys(DEFAULT_GEMINI_PROFILES.profiles).length;
+
+function ensureGeminiProfiles({
+  geminiDir = join(homedir(), ".gemini"),
+  profilesPath = join(geminiDir, "triflux-profiles.json"),
+} = {}) {
+  try {
+    if (!existsSync(geminiDir)) mkdirSync(geminiDir, { recursive: true });
+
+    if (!existsSync(profilesPath)) {
+      writeFileSync(profilesPath, JSON.stringify(DEFAULT_GEMINI_PROFILES, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+      return {
+        ok: true,
+        created: true,
+        added: DEFAULT_PROFILE_COUNT,
+        count: DEFAULT_PROFILE_COUNT,
+        message: null,
+      };
+    }
+
+    let cfg;
+    try {
+      cfg = JSON.parse(readFileSync(profilesPath, "utf8"));
+    } catch {
+      try { copyFileSync(profilesPath, profilesPath + `.bak.${Date.now()}`); } catch {}
+      writeFileSync(profilesPath, JSON.stringify(DEFAULT_GEMINI_PROFILES, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+      return {
+        ok: true,
+        created: true,
+        added: DEFAULT_PROFILE_COUNT,
+        count: DEFAULT_PROFILE_COUNT,
+        message: null,
+      };
+    }
+
+    if (!cfg || typeof cfg !== "object" || Array.isArray(cfg)) cfg = {};
+    if (!cfg.profiles || typeof cfg.profiles !== "object" || Array.isArray(cfg.profiles)) cfg.profiles = {};
+
+    let added = 0;
+    for (const [name, value] of Object.entries(DEFAULT_GEMINI_PROFILES.profiles)) {
+      if (!cfg.profiles[name]) {
+        cfg.profiles[name] = value;
+        added++;
+      }
+    }
+    if (!cfg.model) cfg.model = DEFAULT_GEMINI_PROFILES.model;
+
+    if (added > 0) {
+      writeFileSync(profilesPath, JSON.stringify(cfg, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+    }
+
+    return {
+      ok: true,
+      created: false,
+      added,
+      count: Object.keys(cfg.profiles).length,
+      message: null,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      created: false,
+      added: 0,
+      count: 0,
+      message: error.message,
+    };
+  }
+}
+
+export { DEFAULT_GEMINI_PROFILES, ensureGeminiProfiles };