@triflux/core 10.51.0 → 10.53.0

package/hub/lib/state-snapshot.mjs

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

package/hub/lib/trace-recorder.mjs

@@ -1,153 +0,0 @@
-const VALID_CLIENTS = new Set(["codex", "claude", "gemini", "unknown"]);
-const VALID_PHASES = new Set(["ingress", "handler", "store", "event-loop"]);
-const SAMPLE_LIMIT = 1000;
-
-const categories = new Map();
-const workerDurations = [];
-const workerCounts = {
-  spawned: 0,
-  exited: 0,
-};
-
-function debugInvalid(kind, details) {
-  if (process.env.TFX_TRACE_DEBUG !== "1") return;
-  console.debug(`[trace-recorder] ignored invalid ${kind}`, details);
-}
-
-function normalizeClient(client) {
-  const value = String(client || "unknown").toLowerCase();
-  return VALID_CLIENTS.has(value) ? value : "unknown";
-}
-
-function normalizePhase(phase) {
-  const value = String(phase || "handler");
-  return VALID_PHASES.has(value) ? value : "handler";
-}
-
-function validDuration(durMs) {
-  return Number.isFinite(durMs) && durMs >= 0;
-}
-
-function emptyStats() {
-  return {
-    count: 0,
-    total: 0,
-    min: null,
-    max: null,
-    samples: [],
-    phases: {},
-  };
-}
-
-function addDuration(stats, durMs, phase) {
-  stats.count += 1;
-  stats.total += durMs;
-  stats.min = stats.min == null ? durMs : Math.min(stats.min, durMs);
-  stats.max = stats.max == null ? durMs : Math.max(stats.max, durMs);
-  stats.samples.push(durMs);
-  if (stats.samples.length > SAMPLE_LIMIT) {
-    stats.samples.splice(0, stats.samples.length - SAMPLE_LIMIT);
-  }
-
-  const phaseStats = stats.phases[phase] || emptyPhaseStats();
-  phaseStats.count += 1;
-  phaseStats.total += durMs;
-  phaseStats.min =
-    phaseStats.min == null ? durMs : Math.min(phaseStats.min, durMs);
-  phaseStats.max =
-    phaseStats.max == null ? durMs : Math.max(phaseStats.max, durMs);
-  stats.phases[phase] = phaseStats;
-}
-
-function emptyPhaseStats() {
-  return { count: 0, total: 0, min: null, max: null };
-}
-
-function percentile(samples, percentileValue) {
-  if (!samples.length) return null;
-  const sorted = [...samples].sort((a, b) => a - b);
-  const index = Math.ceil((percentileValue / 100) * sorted.length) - 1;
-  return sorted[Math.max(0, Math.min(sorted.length - 1, index))];
-}
-
-function publicStats(stats) {
-  return {
-    count: stats.count,
-    total: stats.total,
-    min: stats.min,
-    max: stats.max,
-    p50: percentile(stats.samples, 50),
-    p95: percentile(stats.samples, 95),
-    p99: percentile(stats.samples, 99),
-    phases: stats.phases,
-  };
-}
-
-export function recordRequest(
-  category,
-  durMs,
-  client = "unknown",
-  phase = "handler",
-) {
-  if (!category || typeof category !== "string") return;
-  if (!validDuration(durMs)) {
-    debugInvalid("request duration", { category, durMs, client, phase });
-    return;
-  }
-
-  const clientKey = normalizeClient(client);
-  const phaseKey = normalizePhase(phase);
-  const bucket = categories.get(category) || new Map();
-  const stats = bucket.get(clientKey) || emptyStats();
-  addDuration(stats, durMs, phaseKey);
-  bucket.set(clientKey, stats);
-  categories.set(category, bucket);
-}
-
-export function recordWorker(workerId, kind, command, durMs) {
-  if (!workerId || typeof workerId !== "string") return;
-  if (kind === "spawned") {
-    workerCounts.spawned += 1;
-    return;
-  }
-  if (kind !== "exited") return;
-
-  workerCounts.exited += 1;
-  if (durMs == null) return;
-  if (!validDuration(durMs)) {
-    debugInvalid("worker duration", { workerId, kind, command, durMs });
-    return;
-  }
-  workerDurations.push(durMs);
-  if (workerDurations.length > SAMPLE_LIMIT) {
-    workerDurations.splice(0, workerDurations.length - SAMPLE_LIMIT);
-  }
-}
-
-export function snapshot() {
-  const categorySnapshot = {};
-  for (const [category, bucket] of categories.entries()) {
-    categorySnapshot[category] = {};
-    for (const [client, stats] of bucket.entries()) {
-      categorySnapshot[category][client] = publicStats(stats);
-    }
-  }
-
-  return {
-    categories: categorySnapshot,
-    workers: {
-      spawned: workerCounts.spawned,
-      exited: workerCounts.exited,
-      p50: percentile(workerDurations, 50),
-      p95: percentile(workerDurations, 95),
-      p99: percentile(workerDurations, 99),
-    },
-  };
-}
-
-export function reset() {
-  categories.clear();
-  workerDurations.length = 0;
-  workerCounts.spawned = 0;
-  workerCounts.exited = 0;
-}

package/hub/lib/uuidv7.mjs

@@ -1,45 +0,0 @@
-// hub/lib/uuidv7.mjs — UUIDv7 generator (RFC 9562, monotonic)
-import { randomBytes } from "node:crypto";
-
-let _rndPool = Buffer.alloc(0),
-  _rndOff = 0;
-
-function pooledRandom(n) {
-  if (_rndOff + n > _rndPool.length) {
-    _rndPool = randomBytes(256);
-    _rndOff = 0;
-  }
-  const out = Buffer.from(_rndPool.subarray(_rndOff, _rndOff + n));
-  _rndOff += n;
-  return out;
-}
-
-let _lastMs = 0n;
-let _seq = 0;
-
-/** UUIDv7 생성 (RFC 9562, 단조 증가 보장) */
-export function uuidv7() {
-  let now = BigInt(Date.now());
-  if (now <= _lastMs) {
-    _seq++;
-    if (_seq > 0xfff) {
-      now = _lastMs + 1n;
-      _seq = 0;
-    }
-  } else {
-    _seq = 0;
-  }
-  _lastMs = now;
-  const buf = pooledRandom(16);
-  buf[0] = Number((now >> 40n) & 0xffn);
-  buf[1] = Number((now >> 32n) & 0xffn);
-  buf[2] = Number((now >> 24n) & 0xffn);
-  buf[3] = Number((now >> 16n) & 0xffn);
-  buf[4] = Number((now >> 8n) & 0xffn);
-  buf[5] = Number(now & 0xffn);
-  buf[6] = ((_seq >> 8) & 0x0f) | 0x70;
-  buf[7] = _seq & 0xff;
-  buf[8] = (buf[8] & 0x3f) | 0x80;
-  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)}`;
-}