@triflux/remote 10.1.0 → 10.25.1

package/scripts/lib/async.mjs

@@ -0,0 +1,174 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+function jobDir(jobsDir, jobId) {
+  return join(jobsDir, jobId);
+}
+
+function readState(dir) {
+  const path = join(dir, "state.json");
+  if (!existsSync(path)) return null;
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+
+function writeState(dir, state) {
+  writeFileSync(join(dir, "state.json"), `${JSON.stringify(state, null, 2)}\n`);
+}
+
+function fileSize(path) {
+  try {
+    return statSync(path).size;
+  } catch {
+    return 0;
+  }
+}
+
+function isAlive(pid) {
+  if (!pid || pid === "starting") return false;
+  try {
+    process.kill(Number(pid), 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function createJob({
+  jobsDir,
+  command,
+  args = [],
+  env = process.env,
+  cwd = process.cwd(),
+  timeoutMs = 0,
+}) {
+  mkdirSync(jobsDir, { recursive: true });
+  const id = randomUUID();
+  const dir = jobDir(jobsDir, id);
+  mkdirSync(dir, { recursive: true });
+  const startedAt = Date.now();
+  const stdoutPath = join(dir, "result.log");
+  const stderrPath = join(dir, "stderr.log");
+  writeState(dir, {
+    id,
+    state: "starting",
+    startedAt,
+    command,
+    args,
+    timeoutMs,
+  });
+  writeFileSync(join(dir, "pid"), "starting");
+  writeFileSync(join(dir, "start_time"), String(Math.floor(startedAt / 1000)));
+
+  const child = spawn(command, args, {
+    cwd,
+    env,
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  child.unref?.();
+  writeFileSync(join(dir, "pid"), String(child.pid));
+  writeState(dir, {
+    id,
+    state: "running",
+    pid: child.pid,
+    startedAt,
+    command,
+    args,
+    timeoutMs,
+  });
+  child.stdout?.on("data", (chunk) => {
+    writeFileSync(stdoutPath, chunk, { flag: "a" });
+  });
+  child.stderr?.on("data", (chunk) => {
+    writeFileSync(stderrPath, chunk, { flag: "a" });
+  });
+  let timer = null;
+  let timedOut = false;
+  if (timeoutMs > 0) {
+    timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        process.kill(child.pid, "SIGTERM");
+      } catch {
+        // Process already exited.
+      }
+    }, timeoutMs);
+    timer.unref?.();
+  }
+  child.on("exit", (code) => {
+    if (timer) clearTimeout(timer);
+    const exitCode = timedOut ? 124 : (code ?? 1);
+    writeFileSync(join(dir, "exit_code"), String(exitCode));
+    writeFileSync(join(dir, "done"), "");
+    writeState(dir, {
+      id,
+      state: exitCode === 0 ? "done" : exitCode === 124 ? "timeout" : "failed",
+      pid: child.pid,
+      startedAt,
+      finishedAt: Date.now(),
+      exitCode,
+      command,
+      args,
+      timeoutMs,
+    });
+  });
+
+  return { id, dir, pid: child.pid };
+}
+
+export function getJobStatus(jobId, { jobsDir }) {
+  const dir = jobDir(jobsDir, jobId);
+  if (!existsSync(dir))
+    return { state: "error", text: "error: job not found", exitCode: 1 };
+  const state = readState(dir);
+  if (state?.state === "done") return { ...state, text: "done" };
+  if (state?.state === "timeout") return { ...state, text: "timeout" };
+  if (state?.state === "failed") return { ...state, text: "failed" };
+  const pidText = existsSync(join(dir, "pid"))
+    ? readFileSync(join(dir, "pid"), "utf8").trim()
+    : "";
+  if (pidText === "starting")
+    return { ...(state ?? {}), state: "starting", text: "starting" };
+  if (isAlive(pidText)) {
+    const start =
+      Number(readFileSync(join(dir, "start_time"), "utf8")) ||
+      Math.floor(Date.now() / 1000);
+    const elapsed = Math.max(0, Math.floor(Date.now() / 1000) - start);
+    const bytes = fileSize(join(dir, "result.log"));
+    return {
+      ...(state ?? {}),
+      state: "running",
+      text: `running elapsed=${elapsed}s output=${bytes}B`,
+    };
+  }
+  return { ...(state ?? {}), state: "failed", text: "failed" };
+}
+
+export function getJobResult(jobId, { jobsDir }) {
+  const dir = jobDir(jobsDir, jobId);
+  if (!existsSync(dir)) throw new Error("job not found");
+  const status = getJobStatus(jobId, { jobsDir });
+  if (!["done", "timeout", "failed"].includes(status.state)) {
+    throw new Error("job still running");
+  }
+  const stdout = existsSync(join(dir, "result.log"))
+    ? readFileSync(join(dir, "result.log"), "utf8")
+    : "";
+  const stderr = existsSync(join(dir, "stderr.log"))
+    ? readFileSync(join(dir, "stderr.log"), "utf8")
+    : "";
+  return {
+    state: status.state,
+    exitCode: status.exitCode ?? 1,
+    stdout: stdout || stderr,
+    stderr,
+  };
+}

package/scripts/lib/claudemd-scanner.mjs

@@ -0,0 +1,223 @@
+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/cli-agy.mjs

@@ -0,0 +1,62 @@
+// cli-agy.mjs — Antigravity (agy) CLI adapter (Phase 0 PoC).
+//
+// 책임: agy --print 는 stdin-only 이므로 plan() 에서 stdinMode="pipe" 시그널을 반환한다.
+// positional prompt 패턴은 환영 메시지 폴백을 유발하므로 사용 금지.
+//
+// 출처: scripts/tfx-route.sh route_agent() L1052-L1059, run_codex_exec() L2036-L2046.
+//        .claude/rules/tfx-update-logic.md Antigravity CLI 1.0.0 정밀 sanity matrix.
+
+export const id = "agy";
+export const cliType = "antigravity";
+export const command = "agy";
+
+const AGENT_PROFILES = {
+  antigravity: {
+    profile: "agy_v1",
+    timeoutSec: 900,
+    runMode: "bg",
+    opusOversight: false,
+    mcpHint: "docs",
+  },
+  agy: {
+    profile: "agy_v1",
+    timeoutSec: 900,
+    runMode: "bg",
+    opusOversight: false,
+    mcpHint: "docs",
+  },
+};
+
+const DEFAULT_PROFILE = AGENT_PROFILES.antigravity;
+
+export function plan({
+  agent,
+  prompt = "",
+  mcpProfile = "auto",
+  timeoutSec,
+  contextFile,
+} = {}) {
+  if (!agent) {
+    throw new Error("[cli-agy] agent required");
+  }
+  const cfg = AGENT_PROFILES[agent] ?? DEFAULT_PROFILE;
+  const effectiveTimeoutSec =
+    Number.isFinite(timeoutSec) && timeoutSec > 0 ? timeoutSec : cfg.timeoutSec;
+  return {
+    command,
+    profile: cfg.profile,
+    effort: cfg.profile,
+    args: ["--print", "--dangerously-skip-permissions"],
+    stdinMode: "pipe",
+    timeoutMs: effectiveTimeoutSec * 1000,
+    runMode: cfg.runMode,
+    opusOversight: cfg.opusOversight,
+    mcpProfile: mcpProfile === "auto" ? cfg.mcpHint : mcpProfile,
+    promptLength: prompt.length,
+    contextFile: contextFile || null,
+  };
+}
+
+export function describe() {
+  return { id, cliType, command, agents: Object.keys(AGENT_PROFILES) };
+}

package/scripts/lib/cli-claude.mjs

@@ -0,0 +1,78 @@
+// cli-claude.mjs — Claude native adapter (Phase 0 PoC).
+//
+// 책임: Claude 는 외부 CLI 가 아닌 Claude Code Agent 도구로 dispatch 된다. plan() 은
+// command=null 을 반환하고 호출자가 Agent() 로 라우팅하도록 신호한다.
+//
+// 출처: scripts/tfx-route.sh route_agent() L1062-L1063 (explore|claude),
+//        L1196-L1203 (TFX_CLI_MODE=gemini fallback), TFX_VERIFIER_OVERRIDE=claude.
+
+export const id = "claude";
+export const cliType = "claude-native";
+export const command = null;
+
+const AGENT_PROFILES = {
+  explore: {
+    timeoutSec: 600,
+    runMode: "fg",
+    opusOversight: false,
+    model: "haiku",
+  },
+  claude: {
+    timeoutSec: 600,
+    runMode: "fg",
+    opusOversight: false,
+    model: "haiku",
+  },
+  "test-engineer": {
+    timeoutSec: 1200,
+    runMode: "bg",
+    opusOversight: false,
+    model: "sonnet",
+  },
+  "qa-tester": {
+    timeoutSec: 1200,
+    runMode: "bg",
+    opusOversight: false,
+    model: "sonnet",
+  },
+  verifier: {
+    timeoutSec: 1200,
+    runMode: "fg",
+    opusOversight: false,
+    model: "sonnet",
+  },
+};
+
+const DEFAULT_PROFILE = AGENT_PROFILES.explore;
+
+export function plan({
+  agent,
+  prompt = "",
+  mcpProfile = "auto",
+  timeoutSec,
+  contextFile,
+} = {}) {
+  if (!agent) {
+    throw new Error("[cli-claude] agent required");
+  }
+  const cfg = AGENT_PROFILES[agent] ?? DEFAULT_PROFILE;
+  const effectiveTimeoutSec =
+    Number.isFinite(timeoutSec) && timeoutSec > 0 ? timeoutSec : cfg.timeoutSec;
+  return {
+    command,
+    profile: "claude-native",
+    effort: "n/a",
+    timeoutMs: effectiveTimeoutSec * 1000,
+    runMode: cfg.runMode,
+    opusOversight: cfg.opusOversight,
+    model: cfg.model,
+    mcpProfile: mcpProfile === "auto" ? null : mcpProfile,
+    promptLength: prompt.length,
+    contextFile: contextFile || null,
+    note: "Claude native — dispatched via Claude Code Agent tool, not CLI",
+  };
+}
+
+export function describe() {
+  return { id, cliType, command, agents: Object.keys(AGENT_PROFILES) };
+}