@triflux/remote 10.0.1 → 10.25.1

package/scripts/lib/env-probe.mjs

@@ -0,0 +1,269 @@
+import { execSync, spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { whichCommand, whichCommandAsync } from "@triflux/core/hub/platform.mjs";
+
+const HUB_DEFAULT_PORT = 27888;
+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 = resolveDefaultStatusUrl(),
+  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,
+  };
+}
+
+export function resolveDefaultStatusUrl(env = process.env) {
+  const envPort = Number.parseInt(String(env?.TFX_HUB_PORT ?? ""), 10);
+  const port =
+    Number.isFinite(envPort) && envPort > 0 ? envPort : HUB_DEFAULT_PORT;
+  return `http://127.0.0.1:${port}/status`;
+}
+
+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 = resolveDefaultStatusUrl(),
+  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], {
+      env: { ...process.env, TFX_HUB_PORT: String(new URL(statusUrl).port) },
+      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/env.mjs

@@ -0,0 +1,14 @@
+export function buildPreflightEnv(env = process.env) {
+  return {
+    ...env,
+    GIT_TERMINAL_PROMPT: env.GIT_TERMINAL_PROMPT ?? "0",
+    GIT_ASKPASS: env.GIT_ASKPASS ?? "false",
+    npm_config_yes: env.npm_config_yes ?? "true",
+  };
+}
+
+export function shouldWarnGhAuth(env = process.env, checks = {}) {
+  if (!checks.ghExists) return false;
+  if (env.GH_TOKEN || env.GITHUB_TOKEN) return false;
+  return checks.ghAuthenticated === false;
+}

package/scripts/lib/gemini-profiles.mjs

@@ -0,0 +1,119 @@
+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 };

package/scripts/lib/handoff.mjs

@@ -0,0 +1,187 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { findAllClaudeMdPaths } from "./claudemd-scanner.mjs";
+
+function runCommand(command, cwd, executor = execSync) {
+  try {
+    const output = executor(command, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
+    });
+    return String(output || "").trimEnd();
+  } catch {
+    return "";
+  }
+}
+
+function parseStatusLines(statusText) {
+  const lines = String(statusText || "")
+    .split(/\r?\n/u)
+    .filter(Boolean);
+  const changedFiles = [];
+  const status = [];
+
+  for (const line of lines) {
+    const normalized = line.trimEnd();
+    if (!normalized) continue;
+
+    const rawStatus = normalized.slice(0, 2).trim() || "??";
+    const rawPath = normalized.slice(3).trim();
+    const filePath = rawPath.includes(" -> ")
+      ? rawPath.split(" -> ").at(-1)?.trim()
+      : rawPath;
+    if (!filePath) continue;
+
+    changedFiles.push(filePath);
+    status.push({ path: filePath, status: rawStatus });
+  }
+
+  return {
+    changedFiles: Array.from(new Set(changedFiles)),
+    status,
+  };
+}
+
+function normalizeDecisionLine(line) {
+  return String(line || "")
+    .trim()
+    .replace(/^[-*]\s+/u, "")
+    .trim();
+}
+
+function parseDecisionFile(decisionFile) {
+  if (!decisionFile) return [];
+  const absolute = resolve(decisionFile);
+  if (!existsSync(absolute)) return [];
+
+  const raw = readFileSync(absolute, "utf8");
+  return raw
+    .split(/\r?\n/u)
+    .map(normalizeDecisionLine)
+    .filter((line) => line.length > 0);
+}
+
+function normalizeDecisions(decisions, decisionFile) {
+  const merged = [
+    ...(Array.isArray(decisions) ? decisions : []),
+    ...parseDecisionFile(decisionFile),
+  ]
+    .map(normalizeDecisionLine)
+    .filter(Boolean);
+
+  return Array.from(new Set(merged));
+}
+
+function formatAheadBehind(value) {
+  if (!value) return null;
+  const [behindRaw, aheadRaw] = value.split(/\s+/u);
+  const behind = Number.parseInt(behindRaw, 10);
+  const ahead = Number.parseInt(aheadRaw, 10);
+  if (!Number.isFinite(behind) || !Number.isFinite(ahead)) return null;
+  return { ahead, behind };
+}
+
+export function collectHandoffContext(options = {}) {
+  const cwd = resolve(options.cwd || process.cwd());
+  const executor =
+    typeof options.commandRunner === "function"
+      ? options.commandRunner
+      : execSync;
+  const target = options.target === "local" ? "local" : "remote";
+  const decisions = normalizeDecisions(options.decisions, options.decisionFile);
+  const generatedAt = options.generatedAt || new Date().toISOString();
+  const claudeMdPaths = Array.isArray(options.claudeMdPaths)
+    ? options.claudeMdPaths
+    : findAllClaudeMdPaths({
+        cwd,
+        homeDir: options.homeDir,
+      });
+
+  const gitRoot = runCommand("git rev-parse --show-toplevel", cwd, executor);
+  const branch =
+    runCommand("git rev-parse --abbrev-ref HEAD", cwd, executor) || null;
+  const shortStatus = runCommand("git status --short", cwd, executor);
+  const diffStat = runCommand("git diff --stat --no-color", cwd, executor);
+  const upstreamRaw = runCommand(
+    "git rev-list --left-right --count @{upstream}...HEAD",
+    cwd,
+    executor,
+  );
+  const parsedStatus = parseStatusLines(shortStatus);
+
+  return {
+    generatedAt,
+    target,
+    cwd,
+    gitRoot: gitRoot || null,
+    repository: gitRoot ? basename(gitRoot) : basename(cwd),
+    branch,
+    upstream: formatAheadBehind(upstreamRaw),
+    changedFiles: parsedStatus.changedFiles,
+    fileStatus: parsedStatus.status,
+    diffStat,
+    decisions,
+    claudeMdPaths,
+  };
+}
+
+export function buildHandoffPrompt(context) {
+  const safeContext = context || collectHandoffContext();
+  const branch = safeContext.branch || "unknown";
+  const upstream = safeContext.upstream
+    ? `ahead ${safeContext.upstream.ahead}, behind ${safeContext.upstream.behind}`
+    : "unknown";
+  const changedFiles =
+    safeContext.changedFiles.length > 0
+      ? safeContext.changedFiles.map((file) => `- ${file}`).join("\n")
+      : "- 변경 파일 없음";
+  const decisions =
+    safeContext.decisions.length > 0
+      ? safeContext.decisions.map((decision) => `- ${decision}`).join("\n")
+      : "- 명시된 결정사항 없음";
+  const claudeMdList =
+    Array.isArray(safeContext.claudeMdPaths) &&
+    safeContext.claudeMdPaths.length > 0
+      ? safeContext.claudeMdPaths.map((path) => `- ${path}`).join("\n")
+      : "- 자동 탐지된 CLAUDE.md 없음";
+  const diffStat = safeContext.diffStat || "(diff stat 없음)";
+
+  return [
+    "## TFX Remote Handoff",
+    `- generated_at: ${safeContext.generatedAt}`,
+    `- target: ${safeContext.target}`,
+    `- repository: ${safeContext.repository}`,
+    `- branch: ${branch} (${upstream})`,
+    `- cwd: ${safeContext.cwd}`,
+    "",
+    "### 변경 파일",
+    changedFiles,
+    "",
+    "### 변경 요약 (git diff --stat)",
+    "```",
+    diffStat,
+    "```",
+    "",
+    "### 결정사항",
+    decisions,
+    "",
+    "### CLAUDE.md 참조",
+    claudeMdList,
+    "",
+    "### 다음 세션 지시",
+    "- 위 변경사항을 먼저 검토하고 누락된 테스트를 확인하세요.",
+    "- 필요 시 CLAUDE.md 지침을 재확인한 뒤 작업을 이어가세요.",
+    "- 작업 완료 후 변경 파일과 검증 결과를 요약하세요.",
+  ].join("\n");
+}
+
+export function serializeHandoff(options = {}) {
+  const context = collectHandoffContext(options);
+  return {
+    ...context,
+    prompt: buildHandoffPrompt(context),
+  };
+}

package/scripts/lib/hook-utils.mjs

@@ -0,0 +1,16 @@
+export function nudge(message) {
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        additionalContext: message,
+      },
+    }),
+  );
+  process.exit(0);
+}
+
+export function deny(reason) {
+  process.stderr.write(reason);
+  process.exit(2);
+}

package/scripts/lib/hub.mjs

@@ -0,0 +1,48 @@
+import { spawn } from "node:child_process";
+
+export function parseHubPort(hubUrl = "") {
+  try {
+    const parsed = new URL(hubUrl);
+    return parsed.port || "27888";
+  } catch {
+    return "27888";
+  }
+}
+
+export async function restartHub({
+  hubUrl = process.env.TFX_HUB_URL || "http://127.0.0.1:27888",
+  hubServer,
+  nodeBin = process.execPath,
+  spawnFn = spawn,
+  fetchFn = globalThis.fetch,
+  sleepMs = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  attempts = 8,
+} = {}) {
+  if (!hubServer) return { ok: false, error: "hub_server_missing" };
+  const port = parseHubPort(hubUrl);
+  const child = spawnFn(nodeBin, [hubServer], {
+    env: { ...process.env, TFX_HUB_PORT: port },
+    stdio: "ignore",
+    detached: true,
+  });
+  child.unref?.();
+
+  for (let i = 0; i < attempts; i += 1) {
+    await sleepMs(500);
+    try {
+      const response = await fetchFn(`${hubUrl.replace(/\/$/, "")}/status`);
+      if (response?.ok) return { ok: true, pid: child.pid };
+    } catch {
+      // Keep polling until attempts are exhausted.
+    }
+  }
+  return { ok: false, pid: child.pid };
+}
+
+export async function withHubRestart({ action, restart }) {
+  const first = await action();
+  if (first?.ok) return first;
+  const restarted = await restart();
+  if (!restarted?.ok) return first;
+  return action();
+}