triflux 10.4.0 → 10.7.0

package/hub/lib/spawn-trace.mjs

@@ -0,0 +1,527 @@
+import * as childProcess from "node:child_process";
+import { EventEmitter } from "node:events";
+import { createWriteStream, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+
+const LOG_DIR = join(homedir(), ".triflux", "logs");
+const DEDUPE_WINDOW_MS = 5_000;
+const RATE_WINDOW_MS = 1_000;
+const WINDOWS_TERMINAL_COMMANDS = new Set([
+  "wt",
+  "wt.exe",
+  "windowsterminal.exe",
+]);
+
+export const MAX_WT_TABS = 8;
+export const MAX_SPAWN_PER_SEC = resolvePositiveInteger(
+  process.env.TRIFLUX_MAX_SPAWN_RATE,
+  10,
+);
+export const MAX_TOTAL_DESCENDANTS = resolvePositiveInteger(
+  process.env.TRIFLUX_MAX_DESCENDANTS,
+  50,
+);
+
+let logDay = "";
+let logStream = null;
+let traceSequence = 0;
+
+const recentSpawnTimes = [];
+const dedupeEntries = new Map();
+const activeChildren = new Map();
+const activeWtChildren = new Set();
+
+function resolvePositiveInteger(...values) {
+  for (const value of values) {
+    const parsed = Number.parseInt(String(value ?? ""), 10);
+    if (Number.isInteger(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+
+  return null;
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function getLogPath(day = nowIso().slice(0, 10)) {
+  return join(LOG_DIR, `spawn-trace-${day}.jsonl`);
+}
+
+function ensureLogStream() {
+  const day = nowIso().slice(0, 10);
+  if (logStream && logDay === day) {
+    return logStream;
+  }
+
+  mkdirSync(LOG_DIR, { recursive: true });
+
+  if (logStream) {
+    try {
+      logStream.end();
+    } catch {
+      /* ignore */
+    }
+  }
+
+  logDay = day;
+  logStream = createWriteStream(getLogPath(day), { flags: "a" });
+  logStream.on("error", () => {
+    /* ignore logging failures */
+  });
+  return logStream;
+}
+
+function appendTrace(data, { sync = false } = {}) {
+  const entry = {
+    ts: nowIso(),
+    session_id: process.env.TRIFLUX_SESSION_ID ?? null,
+    parent_pid: process.pid,
+    ...data,
+  };
+
+  try {
+    ensureLogStream().write(`${JSON.stringify(entry)}\n`);
+  } catch {
+    if (!sync) {
+      /* ignore logging failures */
+    }
+  }
+}
+
+function nextTraceId() {
+  traceSequence += 1;
+  return `spawn-trace-${Date.now()}-${traceSequence}`;
+}
+
+function trimRecentSpawnTimes(now) {
+  while (
+    recentSpawnTimes.length > 0 &&
+    now - recentSpawnTimes[0] >= RATE_WINDOW_MS
+  ) {
+    recentSpawnTimes.shift();
+  }
+}
+
+function trimDedupeEntries(now) {
+  for (const [key, ts] of dedupeEntries.entries()) {
+    if (now - ts >= DEDUPE_WINDOW_MS) {
+      dedupeEntries.delete(key);
+    }
+  }
+}
+
+function stripTraceOptions(options) {
+  if (!options || typeof options !== "object") {
+    return undefined;
+  }
+
+  const { reason: _reason, dedupe: _dedupe, ...rest } = options;
+  return rest;
+}
+
+function getReason(options) {
+  if (!options || typeof options !== "object") {
+    return null;
+  }
+
+  return options.reason ?? null;
+}
+
+function getDedupeKey(options) {
+  if (!options || typeof options !== "object") {
+    return null;
+  }
+
+  return typeof options.dedupe === "string" && options.dedupe.trim()
+    ? options.dedupe.trim()
+    : null;
+}
+
+function getCwd(options) {
+  if (!options || typeof options !== "object") {
+    return process.cwd();
+  }
+
+  return options.cwd || process.cwd();
+}
+
+function getCommandBasename(command) {
+  return basename(String(command || "")).toLowerCase();
+}
+
+function isWindowsTerminalSpawn(command) {
+  return WINDOWS_TERMINAL_COMMANDS.has(getCommandBasename(command));
+}
+
+function createPolicyError(reasonCode, message, meta = {}) {
+  const error = new Error(message);
+  error.code = "TRIFLUX_SPAWN_BLOCKED";
+  error.reasonCode = reasonCode;
+  Object.assign(error, meta);
+  return error;
+}
+
+function logBlocked(traceId, command, args, options, error, extra = {}) {
+  appendTrace({
+    event: "blocked",
+    trace_id: traceId,
+    command,
+    args,
+    cwd: getCwd(options),
+    reason: getReason(options),
+    warning: error.message,
+    warning_code: error.reasonCode || error.code || "unknown",
+    ...extra,
+  });
+}
+
+function enforceGuards(command, args, options) {
+  const now = Date.now();
+  trimRecentSpawnTimes(now);
+  trimDedupeEntries(now);
+
+  const dedupeKey = getDedupeKey(options);
+  if (dedupeKey) {
+    const lastSeenAt = dedupeEntries.get(dedupeKey);
+    if (lastSeenAt != null && now - lastSeenAt < DEDUPE_WINDOW_MS) {
+      return createPolicyError(
+        "dedupe",
+        `spawn-trace dedupe blocked for key "${dedupeKey}"`,
+        { dedupeKey },
+      );
+    }
+  }
+
+  if (recentSpawnTimes.length >= MAX_SPAWN_PER_SEC) {
+    return createPolicyError(
+      "rate_limit",
+      `spawn-trace rate limit exceeded (${MAX_SPAWN_PER_SEC}/sec)`,
+      { maxPerSec: MAX_SPAWN_PER_SEC },
+    );
+  }
+
+  if (activeChildren.size >= MAX_TOTAL_DESCENDANTS) {
+    return createPolicyError(
+      "max_descendants",
+      `spawn-trace max descendants exceeded (${MAX_TOTAL_DESCENDANTS})`,
+      { maxDescendants: MAX_TOTAL_DESCENDANTS },
+    );
+  }
+
+  if (isWindowsTerminalSpawn(command) && activeWtChildren.size >= MAX_WT_TABS) {
+    return createPolicyError(
+      "wt_tab_cap",
+      `spawn-trace Windows Terminal cap exceeded (${MAX_WT_TABS})`,
+      { maxWtTabs: MAX_WT_TABS },
+    );
+  }
+
+  recentSpawnTimes.push(now);
+  if (dedupeKey) {
+    dedupeEntries.set(dedupeKey, now);
+  }
+
+  return null;
+}
+
+function trackChild(child, meta) {
+  if (!child || typeof child.once !== "function") {
+    return child;
+  }
+
+  activeChildren.set(child, meta);
+  if (meta.isWindowsTerminalSpawn) {
+    activeWtChildren.add(child);
+  }
+
+  let finalized = false;
+  const finalize = (event, payload = {}) => {
+    if (finalized) {
+      return;
+    }
+
+    finalized = true;
+    activeChildren.delete(child);
+    activeWtChildren.delete(child);
+
+    appendTrace({
+      event,
+      trace_id: meta.traceId,
+      command: meta.command,
+      args: meta.args,
+      cwd: meta.cwd,
+      reason: meta.reason,
+      child_pid: child.pid ?? null,
+      duration_ms: Date.now() - meta.startedAt,
+      ...payload,
+    });
+  };
+
+  child.once("exit", (code, signal) => {
+    finalize("exit", {
+      exit_code: code,
+      signal: signal ?? null,
+    });
+  });
+
+  child.once("error", (error) => {
+    finalize("error", {
+      error: error.message,
+    });
+  });
+
+  return child;
+}
+
+function createRejectedChild(command, args, error) {
+  const child = new EventEmitter();
+  child.pid = undefined;
+  child.stdin = null;
+  child.stdout = null;
+  child.stderr = null;
+  child.stdio = [null, null, null];
+  child.spawnfile = String(command);
+  child.spawnargs = [String(command), ...args.map((arg) => String(arg))];
+  child.kill = () => false;
+  child.killed = false;
+  child.connected = false;
+  child.exitCode = 1;
+  child.signalCode = null;
+
+  queueMicrotask(() => {
+    child.emit("error", error);
+    child.emit("exit", 1, null);
+    child.emit("close", 1, null);
+  });
+
+  return child;
+}
+
+function normalizeSpawnArgs(args, options) {
+  if (Array.isArray(args)) {
+    return {
+      argsList: [...args],
+      options,
+    };
+  }
+
+  return {
+    argsList: [],
+    options: args,
+  };
+}
+
+function normalizeExecFileArgs(args, options, callback) {
+  let argsList = [];
+  let normalizedOptions;
+  let normalizedCallback;
+
+  if (typeof args === "function") {
+    normalizedCallback = args;
+  } else if (Array.isArray(args)) {
+    argsList = [...args];
+    if (typeof options === "function") {
+      normalizedCallback = options;
+    } else {
+      normalizedOptions = options;
+      if (typeof callback === "function") {
+        normalizedCallback = callback;
+      }
+    }
+  } else {
+    normalizedOptions = args;
+    if (typeof options === "function") {
+      normalizedCallback = options;
+    }
+  }
+
+  return {
+    argsList,
+    options: normalizedOptions,
+    callback: normalizedCallback,
+  };
+}
+
+export function spawn(command, args, options) {
+  const { argsList, options: normalizedOptions } = normalizeSpawnArgs(
+    args,
+    options,
+  );
+  const traceId = nextTraceId();
+  const blockedError = enforceGuards(command, argsList, normalizedOptions);
+  if (blockedError) {
+    logBlocked(traceId, command, argsList, normalizedOptions, blockedError);
+    throw blockedError;
+  }
+
+  const startedAt = Date.now();
+  const child = childProcess.spawn(
+    command,
+    argsList,
+    stripTraceOptions(normalizedOptions),
+  );
+  appendTrace({
+    event: "spawn",
+    trace_id: traceId,
+    command,
+    args: argsList,
+    cwd: getCwd(normalizedOptions),
+    reason: getReason(normalizedOptions),
+    child_pid: child.pid ?? null,
+  });
+
+  return trackChild(child, {
+    traceId,
+    startedAt,
+    command,
+    args: argsList,
+    cwd: getCwd(normalizedOptions),
+    reason: getReason(normalizedOptions),
+    isWindowsTerminalSpawn: isWindowsTerminalSpawn(command),
+  });
+}
+
+export function execFile(file, args, options, callback) {
+  const normalized = normalizeExecFileArgs(args, options, callback);
+  const traceId = nextTraceId();
+  const blockedError = enforceGuards(
+    file,
+    normalized.argsList,
+    normalized.options,
+  );
+  if (blockedError) {
+    logBlocked(traceId, file, normalized.argsList, normalized.options, blockedError);
+    if (typeof normalized.callback === "function") {
+      queueMicrotask(() => normalized.callback(blockedError, "", ""));
+      return createRejectedChild(file, normalized.argsList, blockedError);
+    }
+    throw blockedError;
+  }
+
+  const startedAt = Date.now();
+  const wrappedCallback =
+    typeof normalized.callback === "function"
+      ? (error, stdout, stderr) => normalized.callback(error, stdout, stderr)
+      : undefined;
+
+  const child = childProcess.execFile(
+    file,
+    normalized.argsList,
+    stripTraceOptions(normalized.options),
+    wrappedCallback,
+  );
+
+  appendTrace({
+    event: "spawn",
+    trace_id: traceId,
+    command: file,
+    args: normalized.argsList,
+    cwd: getCwd(normalized.options),
+    reason: getReason(normalized.options),
+    child_pid: child.pid ?? null,
+  });
+
+  return trackChild(child, {
+    traceId,
+    startedAt,
+    command: file,
+    args: normalized.argsList,
+    cwd: getCwd(normalized.options),
+    reason: getReason(normalized.options),
+    isWindowsTerminalSpawn: isWindowsTerminalSpawn(file),
+  });
+}
+
+export function execFileSync(file, args, options) {
+  const normalized = Array.isArray(args)
+    ? { argsList: [...args], options }
+    : { argsList: [], options: args };
+  const traceId = nextTraceId();
+  const blockedError = enforceGuards(
+    file,
+    normalized.argsList,
+    normalized.options,
+  );
+  if (blockedError) {
+    logBlocked(traceId, file, normalized.argsList, normalized.options, blockedError, {
+      sync: true,
+    });
+    throw blockedError;
+  }
+
+  const startedAt = Date.now();
+  appendTrace(
+    {
+      event: "spawn",
+      trace_id: traceId,
+      command: file,
+      args: normalized.argsList,
+      cwd: getCwd(normalized.options),
+      reason: getReason(normalized.options),
+      sync: true,
+    },
+    { sync: true },
+  );
+
+  try {
+    const result = childProcess.execFileSync(
+      file,
+      normalized.argsList,
+      stripTraceOptions(normalized.options),
+    );
+    appendTrace(
+      {
+        event: "exit",
+        trace_id: traceId,
+        command: file,
+        args: normalized.argsList,
+        cwd: getCwd(normalized.options),
+        reason: getReason(normalized.options),
+        exit_code: 0,
+        duration_ms: Date.now() - startedAt,
+        sync: true,
+      },
+      { sync: true },
+    );
+    return result;
+  } catch (error) {
+    appendTrace(
+      {
+        event: "exit",
+        trace_id: traceId,
+        command: file,
+        args: normalized.argsList,
+        cwd: getCwd(normalized.options),
+        reason: getReason(normalized.options),
+        exit_code: error?.status ?? null,
+        signal: error?.signal ?? null,
+        duration_ms: Date.now() - startedAt,
+        error: error?.message,
+        sync: true,
+      },
+      { sync: true },
+    );
+    throw error;
+  }
+}
+
+export const ChildProcess = childProcess.ChildProcess;
+export const _forkChild = childProcess._forkChild;
+export const exec = childProcess.exec;
+export const execSync = childProcess.execSync;
+export const fork = childProcess.fork;
+export const spawnSync = childProcess.spawnSync;
+
+export default {
+  ...childProcess,
+  spawn,
+  execFile,
+  execFileSync,
+  MAX_WT_TABS,
+  MAX_SPAWN_PER_SEC,
+  MAX_TOTAL_DESCENDANTS,
+};

package/hub/lib/ssh-command.mjs

@@ -112,8 +112,10 @@ export function buildSshArgs(host, remoteCmd, opts = {}) {
   const remoteCmdStr = [cmd, ...quotedArgs].join(" ");
 
   const sshArgs = [
-    "-o", `ConnectTimeout=${connectTimeout}`,
-    "-o", "BatchMode=yes",
+    "-o",
+    `ConnectTimeout=${connectTimeout}`,
+    "-o",
+    "BatchMode=yes",
   ];
 
   if (keepalive) {
@@ -189,9 +191,10 @@ export function resolveHostAlias(alias, repoRoot) {
 
 /**
  * 특정 capability를 보유한 호스트 목록을 반환한다.
+ * 명시적 선택 UI에서 바로 리소스 정보를 보여줄 수 있도록 specs를 평탄화한다.
  * @param {string} capability — e.g. "codex", "claude", "gpu"
  * @param {string} [repoRoot]
- * @returns {Array<{ name: string, config: object }>}
+ * @returns {Array<{ name: string, config: object, specs: { cores?: number, ram_gb?: number } }>}
  */
 export function selectHostForCapability(capability, repoRoot) {
   loadHostsCache(repoRoot);
@@ -199,12 +202,39 @@ export function selectHostForCapability(capability, repoRoot) {
   const matches = [];
   for (const [name, cfg] of Object.entries(hostsCache.hosts || {})) {
     if (cfg.capabilities?.includes(capability)) {
-      matches.push({ name, config: cfg });
+      matches.push({
+        name,
+        config: cfg,
+        specs: {
+          cores: cfg.specs?.cores,
+          ram_gb: cfg.specs?.ram_gb,
+        },
+      });
     }
   }
   return matches;
 }
 
+/**
+ * 특정 capability를 가진 호스트를 리소스 기준으로 정렬해 반환한다.
+ * 자동 선택은 하지 않고, 명시적 선택 목록 정렬에만 사용한다.
+ * @param {string} capability — e.g. "codex", "claude", "gpu"
+ * @param {"cores"|"ram_gb"} sortBy
+ * @param {string} [repoRoot]
+ * @returns {Array<{ name: string, config: object, specs: { cores?: number, ram_gb?: number } }>}
+ */
+export function selectHostByResources(capability, sortBy, repoRoot) {
+  if (sortBy !== "cores" && sortBy !== "ram_gb") {
+    throw new TypeError('sortBy must be "cores" or "ram_gb"');
+  }
+
+  return selectHostForCapability(capability, repoRoot).sort((a, b) => {
+    const aValue = a.specs?.[sortBy] ?? -Infinity;
+    const bValue = b.specs?.[sortBy] ?? -Infinity;
+    return bValue - aValue;
+  });
+}
+
 /** hosts.json 캐시 초기화 (테스트용) */
 export function resetHostsCache() {
   hostsCache = null;

package/hub/lib/ssh-retry.mjs

@@ -21,7 +21,11 @@ const TRANSIENT_RE =
  * @returns {string|Buffer} ssh stdout
  */
 export function execSshWithRetry(args, opts = {}) {
-  const { maxRetries = DEFAULT_MAX_RETRIES, baseDelayMs = DEFAULT_BASE_DELAY_MS, ...execOpts } = opts;
+  const {
+    maxRetries = DEFAULT_MAX_RETRIES,
+    baseDelayMs = DEFAULT_BASE_DELAY_MS,
+    ...execOpts
+  } = opts;
 
   let lastError;
   for (let attempt = 0; attempt <= maxRetries; attempt++) {

package/hub/lib/uuidv7.mjs

@@ -1,7 +1,8 @@
 // hub/lib/uuidv7.mjs — UUIDv7 generator (RFC 9562, monotonic)
-import { randomBytes } from 'node:crypto';
+import { randomBytes } from "node:crypto";
 
-let _rndPool = Buffer.alloc(0), _rndOff = 0;
+let _rndPool = Buffer.alloc(0),
+  _rndOff = 0;
 
 function pooledRandom(n) {
   if (_rndOff + n > _rndPool.length) {
@@ -39,6 +40,6 @@ export function uuidv7() {
   buf[6] = ((_seq >> 8) & 0x0f) | 0x70;
   buf[7] = _seq & 0xff;
   buf[8] = (buf[8] & 0x3f) | 0x80;
-  const h = buf.toString('hex');
+  const h = buf.toString("hex");
   return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
 }