@triflux/core 10.1.0 → 10.25.1

package/hub/lib/ssh-command.mjs

@@ -2,26 +2,21 @@
 // PowerShell 호스트에 bash 문법(2>/dev/null, &&, $())을 보내는 사고를 방지한다.
 // 모든 SSH 명령 생성 코드에서 이 유틸리티를 사용할 것.
 
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { readHost, readHosts, resolveHost } from "./hosts-compat.mjs";
 
 /** hosts.json 캐시 (프로세스 수명 동안 유지) */
 let hostsCache = null;
+let hostsCacheRoot = null;
 
 /**
  * hosts.json을 로드하여 캐시한다.
  * @param {string} [repoRoot] — 프로젝트 루트 경로
  */
 function loadHostsCache(repoRoot) {
-  if (hostsCache) return;
-  try {
-    const hostsPath = repoRoot
-      ? join(repoRoot, "references", "hosts.json")
-      : join(process.cwd(), "references", "hosts.json");
-    hostsCache = JSON.parse(readFileSync(hostsPath, "utf8"));
-  } catch {
-    hostsCache = { hosts: {} };
-  }
+  const cacheKey = repoRoot || process.cwd();
+  if (hostsCache && hostsCacheRoot === cacheKey) return;
+  hostsCache = readHosts(repoRoot);
+  hostsCacheRoot = cacheKey;
 }
 
 /**
@@ -33,7 +28,7 @@ function loadHostsCache(repoRoot) {
 export function detectHostOs(hostAlias, repoRoot) {
   loadHostsCache(repoRoot);
 
-  const hostCfg = hostsCache.hosts?.[hostAlias];
+  const hostCfg = resolveHost(hostAlias, repoRoot)?.host;
   if (hostCfg?.os === "windows") return "windows";
   if (hostCfg?.os) return "posix";
 
@@ -112,8 +107,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) {
@@ -166,7 +163,7 @@ export function validateCommandForOs(command, os) {
  */
 export function getHostConfig(hostAlias, repoRoot) {
   loadHostsCache(repoRoot);
-  return hostsCache.hosts?.[hostAlias] ?? null;
+  return readHost(hostAlias, repoRoot);
 }
 
 /**
@@ -178,20 +175,15 @@ export function getHostConfig(hostAlias, repoRoot) {
 export function resolveHostAlias(alias, repoRoot) {
   loadHostsCache(repoRoot);
 
-  if (hostsCache.hosts?.[alias]) return alias;
-
-  for (const [name, cfg] of Object.entries(hostsCache.hosts || {})) {
-    if (cfg.aliases?.includes(alias)) return name;
-  }
-
-  return null;
+  return resolveHost(alias, repoRoot)?.name ?? null;
 }
 
 /**
  * 특정 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,13 +191,41 @@ 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;
+  hostsCacheRoot = 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/staged-file-detect.mjs

@@ -0,0 +1,43 @@
+import { execFileSync } from "node:child_process";
+
+export function detectChangedFiles({
+  cwd = process.cwd(),
+  includeStaged = true,
+  includeUnstaged = true,
+  includeUntracked = true,
+} = {}) {
+  const staged = includeStaged
+    ? runGit(cwd, ["diff", "--cached", "--name-only"])
+    : [];
+  const unstaged = includeUnstaged ? runGit(cwd, ["diff", "--name-only"]) : [];
+  const untracked = includeUntracked
+    ? runGit(cwd, ["ls-files", "--others", "--exclude-standard"])
+    : [];
+  const files = [...new Set([...staged, ...unstaged, ...untracked])];
+
+  return {
+    stagedCount: staged.length,
+    unstagedCount: unstaged.length,
+    untrackedCount: untracked.length,
+    totalChanged: files.length,
+    files,
+  };
+}
+
+export function hasCodeChange(opts) {
+  return detectChangedFiles(opts).totalChanged > 0;
+}
+
+function runGit(cwd, args) {
+  try {
+    return execFileSync("git", args, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    })
+      .split(/\r?\n/)
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}

package/hub/lib/state-snapshot.mjs

@@ -0,0 +1,293 @@
+import { execFile } from "node:child_process";
+import {
+  copyFile,
+  mkdir,
+  readdir,
+  rename,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const DEFAULT_MAX_SNAPSHOTS = 10;
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+export const CODEX_STATE_INCLUDES = Object.freeze([
+  "config.toml",
+  "AGENTS.md",
+  "skills",
+  "agents",
+  "prompts",
+  "plugins",
+]);
+
+export const CODEX_STATE_EXCLUDES = Object.freeze([
+  "*.sqlite*",
+  ".sandbox*",
+  ".tmp",
+  "_archived_skills",
+  "memories",
+  "cache",
+  "log",
+  "logs",
+  "sessions",
+  "auth.json",
+  ".credentials.json",
+  "*.bak*",
+  "*.tmp-*",
+  "cap_sid",
+  "installation_id",
+  "history.jsonl",
+  "models_cache.json",
+]);
+
+export const GEMINI_STATE_INCLUDES = Object.freeze([
+  "settings.json",
+  "settings.local.json",
+  "GEMINI.md",
+  "commands",
+  "extensions",
+  "plugins",
+  "skills",
+  "agents",
+]);
+
+export const GEMINI_STATE_EXCLUDES = Object.freeze([
+  "*.sqlite*",
+  "cache",
+  "log",
+  "logs",
+  "sessions",
+  "auth.json",
+  ".credentials.json",
+  "*.bak*",
+]);
+
+export const STATE_SNAPSHOT_THRESHOLD_MS = DAY_MS;
+export const STATE_SNAPSHOT_MAX_SNAPSHOTS = DEFAULT_MAX_SNAPSHOTS;
+
+function normalizePath(path) {
+  return String(path || "")
+    .replace(/\\/gu, "/")
+    .replace(/^\/+/u, "");
+}
+
+function globToRegExp(pattern) {
+  const escaped = String(pattern).replace(/[.+^${}()|[\]\\]/gu, "\\$&");
+  return new RegExp(`^${escaped.replace(/\*/gu, ".*")}$`, "u");
+}
+
+function compileExclude(pattern) {
+  const text = normalizePath(pattern).replace(/\/+$/u, "");
+  if (text.includes("*")) {
+    const regex = globToRegExp(text);
+    return (relativePath) => {
+      const normalized = normalizePath(relativePath);
+      return normalized.split("/").some((part) => regex.test(part));
+    };
+  }
+
+  return (relativePath) => {
+    const normalized = normalizePath(relativePath);
+    return normalized.split("/").includes(text);
+  };
+}
+
+function isSubpath(parent, child) {
+  const rel = relative(parent, child);
+  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+
+async function pathStats(path) {
+  try {
+    return await stat(path);
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+async function collectFiles({ sourceDir, includes, excludeMatchers }) {
+  const sourceRoot = resolve(sourceDir);
+  const files = [];
+
+  async function visit(absPath, relativePath) {
+    if (excludeMatchers.some((matcher) => matcher(relativePath))) return;
+
+    const info = await pathStats(absPath);
+    if (!info) return;
+    if (info.isDirectory()) {
+      const children = await readdir(absPath, { withFileTypes: true });
+      for (const child of children) {
+        await visit(join(absPath, child.name), join(relativePath, child.name));
+      }
+      return;
+    }
+    if (info.isFile()) {
+      files.push({
+        absPath,
+        relativePath: normalizePath(relativePath),
+        size: info.size,
+      });
+    }
+  }
+
+  for (const include of includes || []) {
+    const relativeInclude = normalizePath(include);
+    if (!relativeInclude || relativeInclude.startsWith("../")) continue;
+    const absPath = resolve(sourceRoot, relativeInclude);
+    if (!isSubpath(sourceRoot, absPath)) continue;
+    await visit(absPath, relativeInclude);
+  }
+
+  files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  return files;
+}
+
+async function listSnapshots(destDir) {
+  const names = await readdir(destDir).catch((error) => {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  });
+  const snapshots = [];
+  for (const name of names) {
+    if (!name.endsWith(".tar.gz")) continue;
+    const path = join(destDir, name);
+    const info = await pathStats(path);
+    if (info?.isFile()) snapshots.push({ name, path, mtimeMs: info.mtimeMs });
+  }
+  snapshots.sort(
+    (a, b) => b.mtimeMs - a.mtimeMs || b.name.localeCompare(a.name),
+  );
+  return snapshots;
+}
+
+async function copyToStaging(files, stagingDir) {
+  for (const file of files) {
+    const targetPath = join(stagingDir, ...file.relativePath.split("/"));
+    await mkdir(dirname(targetPath), { recursive: true });
+    await copyFile(file.absPath, targetPath);
+  }
+}
+
+async function createArchive({ stagingDir, archivePath, files }) {
+  const listPath = join(stagingDir, ".snapshot-files");
+  const archiveName = normalizePath(relative(stagingDir, archivePath));
+  await writeFile(
+    listPath,
+    `${files.map((file) => file.relativePath).join("\n")}\n`,
+    "utf8",
+  );
+  await execFileAsync(
+    "tar",
+    ["-czf", archiveName, "-C", ".", "-T", ".snapshot-files"],
+    {
+      cwd: stagingDir,
+      windowsHide: true,
+    },
+  );
+  await rm(listPath, { force: true });
+}
+
+async function pruneSnapshots(destDir, maxSnapshots) {
+  const snapshots = await listSnapshots(destDir);
+  const keep = Math.max(1, Number(maxSnapshots) || DEFAULT_MAX_SNAPSHOTS);
+  for (const snapshot of snapshots.slice(keep)) {
+    await rm(snapshot.path, { force: true });
+  }
+}
+
+function formatStamp(date) {
+  return date
+    .toISOString()
+    .replace(/[-:]/gu, "")
+    .replace(/\.\d{3}Z$/u, "Z");
+}
+
+function uniqueSuffix() {
+  return `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+/**
+ * Snapshot selected user state into a rolling tar.gz archive.
+ *
+ * @param {object} options
+ * @param {string} options.sourceDir
+ * @param {string} options.destDir
+ * @param {string[]} options.includes
+ * @param {string[]} options.excludes
+ * @param {number} options.thresholdMs
+ * @param {number} [options.maxSnapshots=10]
+ * @returns {Promise<{skipped: boolean, reason?: string, path?: string, sizeBytes?: number, fileCount?: number}>}
+ */
+export async function snapshotState({
+  sourceDir,
+  destDir,
+  includes,
+  excludes = [],
+  thresholdMs = 0,
+  maxSnapshots = DEFAULT_MAX_SNAPSHOTS,
+}) {
+  const sourceRoot = resolve(sourceDir || "");
+  const destRoot = resolve(destDir || "");
+  const sourceInfo = await pathStats(sourceRoot);
+  if (!sourceInfo?.isDirectory()) {
+    return { skipped: true, reason: "source-missing" };
+  }
+
+  await mkdir(destRoot, { recursive: true });
+  const snapshots = await listSnapshots(destRoot);
+  const newest = snapshots[0];
+  if (
+    newest &&
+    Number(thresholdMs) > 0 &&
+    Date.now() - newest.mtimeMs < Number(thresholdMs)
+  ) {
+    return { skipped: true, reason: "threshold", path: newest.path };
+  }
+
+  const excludeMatchers = excludes.map((pattern) => compileExclude(pattern));
+  const files = await collectFiles({
+    sourceDir: sourceRoot,
+    includes,
+    excludeMatchers,
+  });
+  if (files.length === 0) {
+    return { skipped: true, reason: "empty" };
+  }
+
+  const suffix = uniqueSuffix();
+  const stagingDir = join(tmpdir(), `tfx-state-snapshot-${suffix}`);
+  const tempArchivePath = join(stagingDir, `.state-${suffix}.tar.gz.tmp`);
+  const finalArchivePath = join(
+    destRoot,
+    `state-${formatStamp(new Date())}-${suffix}.tar.gz`,
+  );
+
+  try {
+    await mkdir(stagingDir, { recursive: true });
+    await copyToStaging(files, stagingDir);
+    await createArchive({
+      stagingDir,
+      archivePath: tempArchivePath,
+      files,
+    });
+    await rename(tempArchivePath, finalArchivePath);
+    await pruneSnapshots(destRoot, maxSnapshots);
+    const archiveInfo = await stat(finalArchivePath);
+    const sizeBytes = files.reduce((sum, file) => sum + file.size, 0);
+    return {
+      skipped: false,
+      path: finalArchivePath,
+      sizeBytes: archiveInfo.size || sizeBytes,
+      fileCount: files.length,
+    };
+  } finally {
+    await rm(stagingDir, { recursive: true, force: true });
+    await rm(tempArchivePath, { force: true });
+  }
+}