triflux 10.3.4 → 10.7.0

package/hub/session-fingerprint.mjs

@@ -1,21 +1,21 @@
-import { createHash } from 'node:crypto';
+import { createHash } from "node:crypto";
 
-import { normalizePath } from './platform.mjs';
-import { withRetry } from './workers/worker-utils.mjs';
+import { normalizePath } from "./platform.mjs";
+import { withRetry } from "./workers/worker-utils.mjs";
 
 const ADAPTIVE_FINGERPRINT_VERSION = 1;
-const DEFAULT_SCOPE = 'default';
-const META_PREFIX = 'adaptive_fingerprint:';
+const DEFAULT_SCOPE = "default";
+const META_PREFIX = "adaptive_fingerprint:";
 const DEFAULT_RETRY_OPTIONS = Object.freeze({
   maxAttempts: 3,
   baseDelayMs: 50,
   maxDelayMs: 250,
 });
 const TIME_WINDOWS = Object.freeze([
-  { name: 'overnight', start: 0, end: 5 },
-  { name: 'morning', start: 6, end: 11 },
-  { name: 'afternoon', start: 12, end: 17 },
-  { name: 'evening', start: 18, end: 23 },
+  { name: "overnight", start: 0, end: 5 },
+  { name: "morning", start: 6, end: 11 },
+  { name: "afternoon", start: 12, end: 17 },
+  { name: "evening", start: 18, end: 23 },
 ]);
 const MEMORY_FINGERPRINT_CACHE = new WeakMap();
 
@@ -30,8 +30,8 @@ function toIsoTimestamp(value = Date.now()) {
 
 function toTimestamp(value) {
   if (value instanceof Date) return value.getTime();
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string') {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
     const parsed = Date.parse(value);
     return Number.isFinite(parsed) ? parsed : null;
   }
@@ -39,9 +39,21 @@ function toTimestamp(value) {
 }
 
 function normalizeRetryOptions(options = {}) {
-  const maxAttempts = Math.max(1, Number(options.maxAttempts ?? DEFAULT_RETRY_OPTIONS.maxAttempts) || DEFAULT_RETRY_OPTIONS.maxAttempts);
-  const baseDelayMs = Math.max(0, Number(options.baseDelayMs ?? DEFAULT_RETRY_OPTIONS.baseDelayMs) || DEFAULT_RETRY_OPTIONS.baseDelayMs);
-  const maxDelayMs = Math.max(baseDelayMs, Number(options.maxDelayMs ?? DEFAULT_RETRY_OPTIONS.maxDelayMs) || DEFAULT_RETRY_OPTIONS.maxDelayMs);
+  const maxAttempts = Math.max(
+    1,
+    Number(options.maxAttempts ?? DEFAULT_RETRY_OPTIONS.maxAttempts) ||
+      DEFAULT_RETRY_OPTIONS.maxAttempts,
+  );
+  const baseDelayMs = Math.max(
+    0,
+    Number(options.baseDelayMs ?? DEFAULT_RETRY_OPTIONS.baseDelayMs) ||
+      DEFAULT_RETRY_OPTIONS.baseDelayMs,
+  );
+  const maxDelayMs = Math.max(
+    baseDelayMs,
+    Number(options.maxDelayMs ?? DEFAULT_RETRY_OPTIONS.maxDelayMs) ||
+      DEFAULT_RETRY_OPTIONS.maxDelayMs,
+  );
   return { maxAttempts, baseDelayMs, maxDelayMs };
 }
 
@@ -55,21 +67,23 @@ function metaKey(scope) {
 }
 
 function hashValue(value) {
-  const hash = createHash('sha256');
+  const hash = createHash("sha256");
   hash.update(JSON.stringify(value));
-  return `sha256:${hash.digest('hex')}`;
+  return `sha256:${hash.digest("hex")}`;
 }
 
 function normalizeContextPath(value) {
-  const normalized = normalizePath(String(value ?? ''));
-  return normalized.replace(/\/+/gu, '/').replace(/\/+$/u, '') || '/';
+  const normalized = normalizePath(String(value ?? ""));
+  return normalized.replace(/\/+/gu, "/").replace(/\/+$/u, "") || "/";
 }
 
 function toRelativePath(targetPath, cwd) {
   if (!cwd) return targetPath;
   const base = normalizeContextPath(cwd);
-  if (targetPath === base) return '.';
-  return targetPath.startsWith(`${base}/`) ? targetPath.slice(base.length + 1) : targetPath;
+  if (targetPath === base) return ".";
+  return targetPath.startsWith(`${base}/`)
+    ? targetPath.slice(base.length + 1)
+    : targetPath;
 }
 
 function toUniqueList(values) {
@@ -84,29 +98,49 @@ function toUniqueList(values) {
 }
 
 function collectRawPathCandidates(context = {}) {
-  const direct = [context.file_path, context.filePath, context.path, context.target_path, context.targetPath];
+  const direct = [
+    context.file_path,
+    context.filePath,
+    context.path,
+    context.target_path,
+    context.targetPath,
+  ];
   const fromArrays = [context.files, context.paths, context.targets]
     .filter(Array.isArray)
     .flat()
-    .map((entry) => (typeof entry === 'string' ? entry : entry?.path));
-  return [...direct, ...fromArrays].filter((entry) => typeof entry === 'string' && entry.trim().length > 0);
+    .map((entry) => (typeof entry === "string" ? entry : entry?.path));
+  return [...direct, ...fromArrays].filter(
+    (entry) => typeof entry === "string" && entry.trim().length > 0,
+  );
 }
 
 function collectPathPattern(context = {}) {
   const normalized = toUniqueList(
     collectRawPathCandidates(context)
       .map((entry) => normalizeContextPath(entry))
-      .map((entry) => toRelativePath(entry, context.cwd || context.project_root || context.projectRoot)),
+      .map((entry) =>
+        toRelativePath(
+          entry,
+          context.cwd || context.project_root || context.projectRoot,
+        ),
+      ),
   ).sort();
 
   const primaryPath = normalized[0] ?? null;
   const extensions = normalized
-    .map((entry) => entry.split('/').pop() || '')
-    .map((entry) => (entry.includes('.') ? entry.slice(entry.lastIndexOf('.')).toLowerCase() : 'none'));
-  const extensionCounts = extensions.reduce((acc, ext) => ({
-    ...acc,
-    [ext]: (acc[ext] || 0) + 1,
-  }), {});
+    .map((entry) => entry.split("/").pop() || "")
+    .map((entry) =>
+      entry.includes(".")
+        ? entry.slice(entry.lastIndexOf(".")).toLowerCase()
+        : "none",
+    );
+  const extensionCounts = extensions.reduce(
+    (acc, ext) => ({
+      ...acc,
+      [ext]: (acc[ext] || 0) + 1,
+    }),
+    {},
+  );
 
   return {
     count: normalized.length,
@@ -118,17 +152,24 @@ function collectPathPattern(context = {}) {
 }
 
 function normalizeWorkType(value) {
-  const text = String(value ?? '').trim().toLowerCase();
+  const text = String(value ?? "")
+    .trim()
+    .toLowerCase();
   if (!text) {
-    return { raw: null, normalized: 'general' };
+    return { raw: null, normalized: "general" };
   }
-  const normalized = text.replace(/\s+/gu, '-').replace(/[^a-z0-9-]/gu, '') || 'general';
+  const normalized =
+    text.replace(/\s+/gu, "-").replace(/[^a-z0-9-]/gu, "") || "general";
   return { raw: value, normalized };
 }
 
 function collectActivityTimestamps(context = {}, now = Date.now) {
-  const nowValue = typeof now === 'function' ? now() : now;
-  const fromList = [context.activity_timestamps, context.activityTimestamps, context.timestamps]
+  const nowValue = typeof now === "function" ? now() : now;
+  const fromList = [
+    context.activity_timestamps,
+    context.activityTimestamps,
+    context.timestamps,
+  ]
     .filter(Array.isArray)
     .flat()
     .map(toTimestamp)
@@ -136,17 +177,24 @@ function collectActivityTimestamps(context = {}, now = Date.now) {
   const singles = [context.timestamp, context.started_at, context.startedAt]
     .map(toTimestamp)
     .filter((entry) => entry != null);
-  return fromList.length || singles.length ? [...fromList, ...singles] : [Number(nowValue)];
+  return fromList.length || singles.length
+    ? [...fromList, ...singles]
+    : [Number(nowValue)];
 }
 
 function classifyHour(hour) {
   const safeHour = Number.isFinite(Number(hour)) ? Number(hour) : 0;
-  const matched = TIME_WINDOWS.find((window) => safeHour >= window.start && safeHour <= window.end);
-  return matched?.name || 'overnight';
+  const matched = TIME_WINDOWS.find(
+    (window) => safeHour >= window.start && safeHour <= window.end,
+  );
+  return matched?.name || "overnight";
 }
 
 function buildWindowHistogram(timestamps = []) {
-  const histogram = TIME_WINDOWS.reduce((acc, window) => ({ ...acc, [window.name]: 0 }), {});
+  const histogram = TIME_WINDOWS.reduce(
+    (acc, window) => ({ ...acc, [window.name]: 0 }),
+    {},
+  );
   for (const timestamp of timestamps) {
     const bucket = classifyHour(new Date(timestamp).getHours());
     histogram[bucket] = (histogram[bucket] || 0) + 1;
@@ -155,14 +203,16 @@ function buildWindowHistogram(timestamps = []) {
 }
 
 function dominantWindow(histogram) {
-  const sorted = Object.entries(histogram)
-    .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
-  return sorted[0]?.[0] || 'overnight';
+  const sorted = Object.entries(histogram).sort(
+    (left, right) => right[1] - left[1] || left[0].localeCompare(right[0]),
+  );
+  return sorted[0]?.[0] || "overnight";
 }
 
 function resolveTimezoneName(context = {}) {
-  const fromContext = typeof context.timezone === 'string' ? context.timezone.trim() : '';
-  const fromIntl = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+  const fromContext =
+    typeof context.timezone === "string" ? context.timezone.trim() : "";
+  const fromIntl = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
   return fromContext || fromIntl;
 }
 
@@ -199,11 +249,13 @@ function getMemoryStoreMap(store) {
 
 function readFingerprintFromStore(store, scope) {
   if (!store) return null;
-  if (typeof store.loadAdaptiveFingerprint === 'function') {
+  if (typeof store.loadAdaptiveFingerprint === "function") {
     return store.loadAdaptiveFingerprint(scope);
   }
   if (store.db?.prepare) {
-    const row = store.db.prepare('SELECT value FROM _meta WHERE key = ?').get(metaKey(scope));
+    const row = store.db
+      .prepare("SELECT value FROM _meta WHERE key = ?")
+      .get(metaKey(scope));
     return row?.value ? JSON.parse(row.value) : null;
   }
   return clone(getMemoryStoreMap(store).get(normalizeScope(scope)) || null);
@@ -211,11 +263,12 @@ function readFingerprintFromStore(store, scope) {
 
 function writeFingerprintToStore(store, scope, record) {
   if (!store) return clone(record);
-  if (typeof store.saveAdaptiveFingerprint === 'function') {
+  if (typeof store.saveAdaptiveFingerprint === "function") {
     return store.saveAdaptiveFingerprint(scope, clone(record));
   }
   if (store.db?.prepare) {
-    store.db.prepare('INSERT OR REPLACE INTO _meta (key, value) VALUES (?, ?)')
+    store.db
+      .prepare("INSERT OR REPLACE INTO _meta (key, value) VALUES (?, ?)")
       .run(metaKey(scope), JSON.stringify(record));
     return clone(record);
   }
@@ -225,7 +278,7 @@ function writeFingerprintToStore(store, scope, record) {
 
 function buildHealthSnapshot(base, patch = {}) {
   return {
-    state: patch.state || base.state || 'healthy',
+    state: patch.state || base.state || "healthy",
     retry: { ...base.retry },
     last_success_at: patch.last_success_at ?? base.last_success_at ?? null,
     last_failure_at: patch.last_failure_at ?? base.last_failure_at ?? null,
@@ -235,7 +288,7 @@ function buildHealthSnapshot(base, patch = {}) {
 
 function createInitialHealth(retryOptions) {
   return {
-    state: 'healthy',
+    state: "healthy",
     retry: { ...retryOptions },
     last_success_at: null,
     last_failure_at: null,
@@ -244,7 +297,7 @@ function createInitialHealth(retryOptions) {
 }
 
 function resolveNowValue(now) {
-  return typeof now === 'function' ? now() : now;
+  return typeof now === "function" ? now() : now;
 }
 
 function mergeFingerprintSnapshot(previous, computed, scope) {
@@ -258,7 +311,7 @@ function mergeFingerprintSnapshot(previous, computed, scope) {
 
 function markHealthyHealth(base, now) {
   return buildHealthSnapshot(base, {
-    state: 'healthy',
+    state: "healthy",
     last_success_at: toIsoTimestamp(resolveNowValue(now)),
     last_error: null,
   });
@@ -266,11 +319,11 @@ function markHealthyHealth(base, now) {
 
 function markDegradedHealth(base, now, error) {
   return buildHealthSnapshot(base, {
-    state: 'degraded',
+    state: "degraded",
     last_failure_at: toIsoTimestamp(resolveNowValue(now)),
     last_error: {
-      name: error?.name || 'Error',
-      message: error?.message || 'unknown adaptive fingerprint error',
+      name: error?.name || "Error",
+      message: error?.message || "unknown adaptive fingerprint error",
     },
   });
 }
@@ -279,7 +332,9 @@ export function buildAdaptiveFingerprint(sessionContext = {}, options = {}) {
   const now = options.now ?? Date.now;
   const capturedAt = toIsoTimestamp(resolveNowValue(now));
   const pathPattern = collectPathPattern(sessionContext);
-  const workType = normalizeWorkType(sessionContext.work_type ?? sessionContext.workType);
+  const workType = normalizeWorkType(
+    sessionContext.work_type ?? sessionContext.workType,
+  );
   const timezonePattern = collectTimezonePattern(sessionContext, now);
   const fingerprintId = computeFingerprintSignature({
     path_pattern: pathPattern,
@@ -303,10 +358,18 @@ export async function loadAdaptiveFingerprint(store, scope = DEFAULT_SCOPE) {
   return clone(loaded);
 }
 
-export async function saveAdaptiveFingerprint(store, scope, fingerprint, options = {}) {
+export async function saveAdaptiveFingerprint(
+  store,
+  scope,
+  fingerprint,
+  options = {},
+) {
   const retryOptions = normalizeRetryOptions(options.retryOptions);
   const normalizedScope = normalizeScope(scope);
-  const write = async () => Promise.resolve(writeFingerprintToStore(store, normalizedScope, fingerprint));
+  const write = async () =>
+    Promise.resolve(
+      writeFingerprintToStore(store, normalizedScope, fingerprint),
+    );
   const saved = await withRetry(write, { ...retryOptions });
   return clone(saved);
 }
@@ -324,7 +387,9 @@ export function createAdaptiveFingerprintService(options = {}) {
     const merged = mergeFingerprintSnapshot(previous, computed, scope);
 
     try {
-      const saved = await saveAdaptiveFingerprint(store, scope, merged, { retryOptions });
+      const saved = await saveAdaptiveFingerprint(store, scope, merged, {
+        retryOptions,
+      });
       health = markHealthyHealth(health, now);
       return saved;
     } catch (error) {
@@ -343,7 +408,8 @@ export function createAdaptiveFingerprintService(options = {}) {
 
   return Object.freeze({
     captureFingerprint: capture,
-    computeFingerprint: (sessionContext = {}) => buildAdaptiveFingerprint(sessionContext, { now }),
+    computeFingerprint: (sessionContext = {}) =>
+      buildAdaptiveFingerprint(sessionContext, { now }),
     loadFingerprint: read,
     getHealth,
   });

package/hub/state.mjs

@@ -1,20 +1,34 @@
-import { execSync } from 'node:child_process';
-import { mkdirSync, openSync, closeSync, unlinkSync, writeFileSync, readFileSync, renameSync, existsSync, statSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const PROJECT_ROOT = fileURLToPath(new URL('..', import.meta.url));
-const PID_FILE_NAME = 'hub.pid';
-const LEGACY_STATE_FILE_NAME = 'hub-state.json';
-const LOCK_FILE_NAME = 'hub-start.lock';
+import { execSync } from "node:child_process";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PROJECT_ROOT = fileURLToPath(new URL("..", import.meta.url));
+const PID_FILE_NAME = "hub.pid";
+const LEGACY_STATE_FILE_NAME = "hub-state.json";
+const LOCK_FILE_NAME = "hub-start.lock";
 
 let heldLockPath = null;
 let heldLockFd = null;
 let cachedVersionHash = null;
 
 function getStateDir(options = {}) {
-  return options.stateDir || process.env.TFX_HUB_STATE_DIR?.trim() || join(homedir(), '.claude', 'cache', 'tfx-hub');
+  return (
+    options.stateDir ||
+    process.env.TFX_HUB_STATE_DIR?.trim() ||
+    join(homedir(), ".claude", "cache", "tfx-hub")
+  );
 }
 
 function getStatePath(options = {}) {
@@ -55,25 +69,32 @@ function safeReplaceFile(tempPath, targetPath) {
   try {
     renameSync(tempPath, targetPath);
   } catch (error) {
-    if (!['EEXIST', 'EPERM', 'EACCES'].includes(error?.code)) {
-      try { unlinkSync(tempPath); } catch {}
+    if (!["EEXIST", "EPERM", "EACCES"].includes(error?.code)) {
+      try {
+        unlinkSync(tempPath);
+      } catch {}
       throw error;
     }
-    try { unlinkSync(targetPath); } catch {}
+    try {
+      unlinkSync(targetPath);
+    } catch {}
     renameSync(tempPath, targetPath);
   }
 }
 
 function writeJsonFile(targetPath, payload) {
   const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
-  writeFileSync(tempPath, `${JSON.stringify(payload, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+  writeFileSync(tempPath, `${JSON.stringify(payload, null, 2)}\n`, {
+    encoding: "utf8",
+    mode: 0o600,
+  });
   safeReplaceFile(tempPath, targetPath);
 }
 
 function readJsonFile(filePath) {
   try {
     if (!existsSync(filePath)) return null;
-    return parseJson(readFileSync(filePath, 'utf8'), null);
+    return parseJson(readFileSync(filePath, "utf8"), null);
   } catch {
     return null;
   }
@@ -82,7 +103,7 @@ function readJsonFile(filePath) {
 /**
  * 허브의 현재 상태(PID, 포트, 버전 등)를 파일에 기록합니다.
  * 원자적(atomic) 쓰기를 위해 임시 파일을 생성한 후 교체하는 방식을 사용합니다.
- * 
+ *
  * @param {object} payload - 상태 데이터
  * @param {number} payload.pid - 허브 프로세스 ID
  * @param {number} payload.port - 허브 서버 포트
@@ -93,31 +114,39 @@ function readJsonFile(filePath) {
  * @param {string} [options.stateDir] - 상태 파일이 저장될 디렉토리
  * @returns {object} 기록된 상태 데이터
  */
-export function writeState({ pid, port, version, sessionId, startedAt, ...rest }, options = {}) {
+export function writeState(
+  { pid, port, version, sessionId, startedAt, ...rest },
+  options = {},
+) {
   const stateDir = getStateDir(options);
   const statePath = getStatePath(options);
   const payload = { pid, port, version, sessionId, startedAt, ...rest };
 
   mkdirSync(stateDir, { recursive: true });
   writeJsonFile(statePath, payload);
-  try { unlinkSync(getLegacyStatePath(options)); } catch {}
+  try {
+    unlinkSync(getLegacyStatePath(options));
+  } catch {}
   return payload;
 }
 
 /**
  * 파일로부터 허브의 현재 상태를 읽어옵니다.
- * 
+ *
  * @param {object} [options] - 옵션
  * @param {string} [options.stateDir] - 상태 파일이 저장된 디렉토리
  * @returns {object|null} 읽어온 상태 데이터 또는 실패 시 null
  */
 export function readState(options = {}) {
-  return readJsonFile(getStatePath(options)) ?? readJsonFile(getLegacyStatePath(options));
+  return (
+    readJsonFile(getStatePath(options)) ??
+    readJsonFile(getLegacyStatePath(options))
+  );
 }
 
 /**
  * 지정된 포트에서 실행 중인 허브 서버의 헬스 체크를 수행합니다.
- * 
+ *
  * @param {number|string} port - 서버 포트
  * @param {object} [options] - 옵션
  * @param {number} [options.timeoutMs=1000] - 요청 타임아웃
@@ -133,7 +162,7 @@ export async function isServerHealthy(port, options = {}) {
 
   try {
     const response = await fetch(`${baseUrl}/health`, {
-      method: 'GET',
+      method: "GET",
       signal: AbortSignal.timeout(timeoutMs),
     });
     if (!response.ok) return false;
@@ -147,7 +176,7 @@ export async function isServerHealthy(port, options = {}) {
 /**
  * 현재 프로젝트의 버전 해시를 생성합니다.
  * package.json의 버전과 Git commit SHA를 조합합니다.
- * 
+ *
  * @param {object} [options] - 옵션
  * @param {boolean} [options.force=false] - 캐시를 무시하고 새로 생성할지 여부
  * @returns {string} 버전 해시 문자열
@@ -155,21 +184,21 @@ export async function isServerHealthy(port, options = {}) {
 export function getVersionHash(options = {}) {
   if (cachedVersionHash && !options.force) return cachedVersionHash;
 
-  const packageJsonPath = join(PROJECT_ROOT, 'package.json');
-  const pkg = parseJson(readFileSync(packageJsonPath, 'utf8'), {});
-  const version = String(pkg?.version || '0.0.0').trim();
+  const packageJsonPath = join(PROJECT_ROOT, "package.json");
+  const pkg = parseJson(readFileSync(packageJsonPath, "utf8"), {});
+  const version = String(pkg?.version || "0.0.0").trim();
 
-  let sha = String(process.env.TFX_HUB_GIT_SHA || '').trim();
+  let sha = String(process.env.TFX_HUB_GIT_SHA || "").trim();
   if (!sha) {
     try {
-      sha = execSync('git rev-parse --short HEAD', {
+      sha = execSync("git rev-parse --short HEAD", {
         cwd: PROJECT_ROOT,
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'ignore'],
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
         windowsHide: true,
       }).trim();
     } catch {
-      sha = '';
+      sha = "";
     }
   }
 
@@ -180,7 +209,7 @@ export function getVersionHash(options = {}) {
 /**
  * 허브 시작 시 중복 실행을 방지하기 위한 잠금(lock)을 획득합니다.
  * 이미 실행 중인 다른 프로세스가 있는지 확인하고 유효한 잠금을 획득할 때까지 재시도합니다.
- * 
+ *
  * @param {object} [options] - 옵션
  * @param {number} [options.timeoutMs=3000] - 최대 대기 시간
  * @param {number} [options.pollMs=50] - 재시도 간격
@@ -202,27 +231,37 @@ export async function acquireLock(options = {}) {
 
   while (Date.now() <= deadline) {
     try {
-      const fd = openSync(lockPath, 'wx', 0o600);
-      writeFileSync(fd, `${JSON.stringify({
-        pid: process.pid,
-        createdAt: new Date().toISOString(),
-      }, null, 2)}\n`, 'utf8');
+      const fd = openSync(lockPath, "wx", 0o600);
+      writeFileSync(
+        fd,
+        `${JSON.stringify(
+          {
+            pid: process.pid,
+            createdAt: new Date().toISOString(),
+          },
+          null,
+          2,
+        )}\n`,
+        "utf8",
+      );
       heldLockFd = fd;
       heldLockPath = lockPath;
       return { path: lockPath };
     } catch (error) {
-      if (error?.code !== 'EEXIST') {
+      if (error?.code !== "EEXIST") {
         throw error;
       }
 
       try {
-        const raw = readFileSync(lockPath, 'utf8');
+        const raw = readFileSync(lockPath, "utf8");
         const data = parseJson(raw, {});
         const stats = statSync(lockPath);
         const staleByPid = !isPidAlive(data?.pid);
         const staleByAge = Date.now() - stats.mtimeMs > timeoutMs;
         if (staleByPid || staleByAge) {
-          try { unlinkSync(lockPath); } catch {}
+          try {
+            unlinkSync(lockPath);
+          } catch {}
           continue;
         }
       } catch {}
@@ -236,7 +275,7 @@ export async function acquireLock(options = {}) {
 
 /**
  * 획득했던 잠금을 해제합니다. 잠금 파일을 삭제하고 관련 리소스를 정리합니다.
- * 
+ *
  * @param {object} [options] - 옵션
  * @param {string} [options.lockPath] - 명시적인 잠금 파일 경로
  */
@@ -244,7 +283,9 @@ export function releaseLock(options = {}) {
   const lockPath = options.lockPath || heldLockPath || getLockPath(options);
 
   if (heldLockFd !== null) {
-    try { closeSync(heldLockFd); } catch {}
+    try {
+      closeSync(heldLockFd);
+    } catch {}
     heldLockFd = null;
   }