svn-agent-mcp 1.0.0

package/src/parse/updateText.ts

@@ -0,0 +1,76 @@
+import type { ChangedPath, Conflict } from "../types.js";
+
+export function parseUpdateText(text: string): { changed_paths: ChangedPath[]; conflicts: Conflict[] } {
+  const changed_paths: ChangedPath[] = [];
+  const conflicts: Conflict[] = [];
+  let treeConflictSummaryCount = 0;
+
+  for (const rawLine of text.replace(/\r\n/g, "\n").split("\n")) {
+    const line = rawLine.trimEnd();
+    if (!line) {
+      continue;
+    }
+
+    const summaryMatch = /^\s*Tree conflicts:\s*(\d+)/i.exec(line);
+    if (summaryMatch) {
+      treeConflictSummaryCount = Number.parseInt(summaryMatch[1] ?? "0", 10);
+      continue;
+    }
+
+    const columns = line.slice(0, 5).padEnd(5, " ");
+    const path = line.slice(5).trim();
+    if (!isUpdateStatusColumns(columns)) {
+      continue;
+    }
+    const contentStatus = columns[0] ?? " ";
+    const propStatus = columns[1] ?? " ";
+    const treeStatus = columns[3] ?? " ";
+    const status = firstStatus([contentStatus, propStatus, treeStatus]);
+    if (!status || !path) {
+      continue;
+    }
+
+    changed_paths.push({ status, path });
+    if (contentStatus === "C") {
+      conflicts.push({ path, type: "text" });
+    }
+    if (propStatus === "C") {
+      conflicts.push({ path, type: "prop" });
+    }
+    if (treeStatus === "C") {
+      conflicts.push({ path, type: "tree" });
+    }
+  }
+
+  const detailedTreeConflicts = conflicts.filter((conflict) => conflict.type === "tree").length;
+  for (let index = detailedTreeConflicts; index < treeConflictSummaryCount; index += 1) {
+    conflicts.push({ path: "", type: "tree" });
+  }
+
+  return { changed_paths, conflicts };
+}
+
+// Real update-status lines use four status columns plus a separator space
+// before the path. Informational lines ("Updated to revision 42.",
+// "Updating '.':", "At revision 42.") fail this shape and must not become
+// phantom changed paths.
+function isUpdateStatusColumns(columns: string): boolean {
+  if ((columns[4] ?? " ") !== " ") {
+    return false;
+  }
+  for (let index = 0; index < 4; index += 1) {
+    if (!/^[UGCEADMRB~! ]$/.test(columns[index] ?? " ")) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function firstStatus(columns: string[]): string | null {
+  for (const status of columns) {
+    if (/^[UGCEADMR~!]$/.test(status)) {
+      return status;
+    }
+  }
+  return null;
+}

package/src/runner.ts

@@ -0,0 +1,344 @@
+import { execFile, spawn } from "node:child_process";
+import { isUtf8 } from "node:buffer";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { redactArgv } from "./envelope.js";
+import { readonlyMode } from "./guards.js";
+import type { RunResult } from "./types.js";
+
+const DEFAULT_TIMEOUT_MS = 120000;
+const DEFAULT_MAX_BUFFER = 20 * 1024 * 1024;
+
+export function timeoutMs(): number {
+  const parsed = Number.parseInt(process.env.SVN_AGENT_TIMEOUT_MS ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_TIMEOUT_MS;
+}
+
+export function svnExecutable(): string {
+  return process.env.SVN_AGENT_SVN_PATH || bundledExecutable("svn") || "svn";
+}
+
+export function svnVersionExecutable(): string {
+  const svnPath = process.env.SVN_AGENT_SVN_PATH;
+  if (!svnPath || svnPath === "svn") {
+    return bundledExecutable("svnversion") || "svnversion";
+  }
+
+  return path.join(path.dirname(svnPath), "svnversion.exe");
+}
+
+export function svnAdminExecutable(): string {
+  const svnPath = process.env.SVN_AGENT_SVN_PATH;
+  if (!svnPath || svnPath === "svn") {
+    return bundledExecutable("svnadmin") || "svnadmin";
+  }
+
+  return path.join(path.dirname(svnPath), "svnadmin.exe");
+}
+
+export function dos2UnixExecutable(name: "dos2unix" | "unix2dos"): string {
+  const dir = process.env.SVN_AGENT_DOS2UNIX_DIR;
+  if (dir) {
+    return path.join(dir, `${name}.exe`);
+  }
+
+  return bundledExecutable(name) || name;
+}
+
+function bundledExecutable(name: string): string | null {
+  for (const dir of bundledBinDirs()) {
+    for (const candidate of executableCandidates(dir, name)) {
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+  }
+
+  return null;
+}
+
+function bundledBinDirs(): string[] {
+  const dirs = [
+    process.env.SVN_AGENT_BIN_DIR ? path.resolve(process.env.SVN_AGENT_BIN_DIR) : null,
+    path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "bin")
+  ].filter((dir): dir is string => dir !== null);
+
+  return Array.from(new Set(dirs));
+}
+
+function executableCandidates(dir: string, name: string): string[] {
+  const suffix = process.platform === "win32" ? ".exe" : "";
+  const primary = path.join(dir, `${name}${suffix}`);
+  const fallback = path.join(dir, name);
+  return primary === fallback ? [primary] : [primary, fallback];
+}
+
+export async function runExecutable(
+  executable: string,
+  args: string[],
+  options: { cwd: string; timeout?: number; maxBuffer?: number }
+): Promise<RunResult> {
+  const cwd = path.resolve(options.cwd);
+  const command = redactArgv(executable, args);
+
+  return new Promise((resolve) => {
+    execFile(
+      executable,
+      args,
+      {
+        cwd,
+        env: stableToolEnv(),
+        timeout: options.timeout ?? timeoutMs(),
+        maxBuffer: options.maxBuffer ?? DEFAULT_MAX_BUFFER,
+        windowsHide: true,
+        encoding: "buffer"
+      },
+      (error, stdoutBuffer, stderrBuffer) => {
+        const stdout = decodeOutput(stdoutBuffer);
+        const stderr = decodeOutput(stderrBuffer);
+        const execError = error as (NodeJS.ErrnoException & { killed?: boolean; signal?: NodeJS.Signals }) | null;
+        const killedByTimeout =
+          Boolean(execError?.killed) && (execError?.signal === "SIGTERM" || execError?.code === "ETIMEDOUT");
+
+        const result: RunResult = {
+          command,
+          cwd,
+          executable,
+          args,
+          exitCode: typeof execError?.code === "number" ? execError.code : execError ? 1 : 0,
+          signal: (execError?.signal as NodeJS.Signals | null | undefined) ?? null,
+          stdout,
+          stderr,
+          timedOut: killedByTimeout
+        };
+        if (typeof execError?.code === "string") {
+          result.errorCode = execError.code;
+        }
+        resolve(result);
+      }
+    );
+  });
+}
+
+export async function runSvn(args: string[], cwd: string): Promise<RunResult> {
+  return runExecutable(svnExecutable(), nonInteractiveSvnArgs(args), { cwd });
+}
+
+export async function runSvnStreamingLines(
+  args: string[],
+  cwd: string,
+  onStdoutLine: (line: string) => void,
+  options: { stdoutLineLimit?: number; timeout?: number } = {}
+): Promise<RunResult> {
+  return runExecutableStreamingLines(svnExecutable(), nonInteractiveSvnArgs(args), { cwd, ...options }, onStdoutLine);
+}
+
+export async function runExecutableStreamingLines(
+  executable: string,
+  args: string[],
+  options: { cwd: string; stdoutLineLimit?: number; timeout?: number; stderrMaxBuffer?: number },
+  onStdoutLine: (line: string) => void
+): Promise<RunResult> {
+  const cwd = path.resolve(options.cwd);
+  const command = redactArgv(executable, args);
+  const stdoutLineLimit = options.stdoutLineLimit ?? 200;
+
+  return new Promise((resolve) => {
+    const child = spawn(executable, args, {
+      cwd,
+      env: stableToolEnv(),
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutLines: string[] = [];
+    const stderrBuffers: Buffer[] = [];
+    const stderrMaxBuffer = options.stderrMaxBuffer ?? DEFAULT_MAX_BUFFER;
+    let stdoutCarry: Buffer = Buffer.alloc(0);
+    let timedOut = false;
+    let settled = false;
+    let stderrBytes = 0;
+    let stderrTruncated = false;
+
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      settle({
+        exitCode: null,
+        signal: "SIGTERM",
+        timedOut: true
+      });
+    }, options.timeout ?? timeoutMs());
+
+    child.stdout.on("data", (chunk: Buffer) => {
+      if (settled) {
+        return;
+      }
+      consumeStdout(chunk);
+    });
+    child.stderr.on("data", (chunk: Buffer) => {
+      if (settled) {
+        return;
+      }
+      appendStderr(chunk);
+    });
+
+    child.on("error", (error: NodeJS.ErrnoException) => {
+      settle({
+        exitCode: 1,
+        signal: null,
+        stderrOverride: error.message,
+        timedOut,
+        errorCode: error.code
+      });
+    });
+
+    child.on("close", (code, signal) => {
+      settle({ exitCode: code, signal, timedOut });
+    });
+
+    function settle(input: {
+      exitCode: number | null;
+      signal: NodeJS.Signals | null;
+      timedOut: boolean;
+      stderrOverride?: string | undefined;
+      errorCode?: string | undefined;
+    }): void {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      consumeStdout(Buffer.alloc(0), true);
+      const stderrText =
+        decodeOutput(Buffer.concat(stderrBuffers)) + (stderrTruncated ? "\n[stderr truncated]" : "");
+      resolve({
+        command,
+        cwd,
+        executable,
+        args,
+        exitCode: input.exitCode,
+        signal: input.signal,
+        stdout: stdoutLines.join("\n"),
+        stderr: input.stderrOverride ?? stderrText,
+        timedOut: input.timedOut,
+        errorCode: input.errorCode,
+        truncated: stderrTruncated
+      });
+    }
+
+    function appendStderr(chunk: Buffer): void {
+      if (stderrTruncated) {
+        return;
+      }
+
+      const remaining = stderrMaxBuffer - stderrBytes;
+      if (remaining <= 0) {
+        stderrTruncated = true;
+        return;
+      }
+
+      if (chunk.length > remaining) {
+        stderrBuffers.push(chunk.subarray(0, remaining));
+        stderrBytes = stderrMaxBuffer;
+        stderrTruncated = true;
+        return;
+      }
+
+      stderrBuffers.push(chunk);
+      stderrBytes += chunk.length;
+    }
+
+    // Byte-level line splitting so each line can take the latin1 fallback in
+    // decodeOutput; a text StringDecoder would lossily replace non-UTF8 bytes
+    // before the fallback could see them.
+    function consumeStdout(chunk: Buffer, flush = false): void {
+      if (chunk.length === 0 && !flush) {
+        return;
+      }
+
+      stdoutCarry = stdoutCarry.length === 0 ? chunk : Buffer.concat([stdoutCarry, chunk]);
+      let newlineIndex: number;
+      while ((newlineIndex = stdoutCarry.indexOf(0x0a)) !== -1) {
+        emitStdoutLine(stdoutCarry.subarray(0, newlineIndex));
+        stdoutCarry = stdoutCarry.subarray(newlineIndex + 1);
+      }
+      if (flush && stdoutCarry.length > 0) {
+        emitStdoutLine(stdoutCarry);
+        stdoutCarry = Buffer.alloc(0);
+      }
+    }
+
+    function emitStdoutLine(lineBytes: Buffer): void {
+      const trimmed = lineBytes.length > 0 && lineBytes[lineBytes.length - 1] === 0x0d
+        ? lineBytes.subarray(0, lineBytes.length - 1)
+        : lineBytes;
+      const line = decodeOutput(trimmed);
+      onStdoutLine(line);
+      if (stdoutLines.length < stdoutLineLimit) {
+        stdoutLines.push(line);
+      }
+    }
+  });
+}
+
+export async function runSvnVersion(target: string, cwd: string): Promise<RunResult> {
+  return runExecutable(svnVersionExecutable(), [target], { cwd });
+}
+
+export async function runDos2Unix(name: "dos2unix" | "unix2dos", args: string[], cwd: string): Promise<RunResult> {
+  return runExecutable(dos2UnixExecutable(name), args, { cwd });
+}
+
+export async function startupProbe(cwd = process.cwd()): Promise<{
+  readonly: boolean;
+  svn: { ok: boolean; version: string | null; note: string };
+  dos2unix: { ok: boolean; note: string };
+  unix2dos: { ok: boolean; note: string };
+}> {
+  const svn = await runExecutable(svnExecutable(), ["--version", "--quiet"], { cwd, timeout: 10000 });
+  const dos2unix = await runExecutable(dos2UnixExecutable("dos2unix"), ["--version"], { cwd, timeout: 10000 });
+  const unix2dos = await runExecutable(dos2UnixExecutable("unix2dos"), ["--version"], { cwd, timeout: 10000 });
+
+  return {
+    readonly: readonlyMode(),
+    svn: {
+      ok: svn.exitCode === 0,
+      version: svn.exitCode === 0 ? svn.stdout.trim() : null,
+      note: svn.exitCode === 0 ? "" : "svn unavailable"
+    },
+    dos2unix: {
+      ok: dos2unix.exitCode === 0,
+      note: dos2unix.exitCode === 0 ? firstLine(dos2unix.stdout) : "dos2unix unavailable"
+    },
+    unix2dos: {
+      ok: unix2dos.exitCode === 0,
+      note: unix2dos.exitCode === 0 ? firstLine(unix2dos.stdout) : "unix2dos unavailable"
+    }
+  };
+}
+
+function firstLine(text: string): string {
+  return text.replace(/\r\n/g, "\n").split("\n")[0] ?? "";
+}
+
+function decodeOutput(buffer: Buffer | string): string {
+  if (typeof buffer === "string") {
+    return buffer;
+  }
+
+  return isUtf8(buffer) ? buffer.toString("utf8") : buffer.toString("latin1");
+}
+
+function nonInteractiveSvnArgs(args: string[]): string[] {
+  return args.includes("--non-interactive") ? args : ["--non-interactive", ...args];
+}
+
+function stableToolEnv(): NodeJS.ProcessEnv {
+  return {
+    ...process.env,
+    LC_ALL: "C",
+    LANG: "C",
+    LANGUAGE: "C"
+  };
+}

package/src/tools/composite.ts

@@ -0,0 +1,289 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createEnvelope, envelopeFromRun, failEnvelope, noteFromRun } from "../envelope.js";
+import { converterForEolTarget, convertEol, isBinaryKind, normalizeEolTarget, sniffEol } from "../eol.js";
+import {
+  assertExistingTargets,
+  neverCommitHit,
+  neverCommitNote,
+  readonlyMode,
+  repoRelativePath,
+  requireExplicitPaths,
+  resolveCwd,
+  resolveTargetsInsideWc
+} from "../guards.js";
+import { parseDiffText } from "../parse/diffText.js";
+import { runSvn, runSvnVersion } from "../runner.js";
+import type { ToolEnvelope } from "../types.js";
+import {
+  defaultDiffLineLimit,
+  dryRiskSignals,
+  eolCheck,
+  getWcContext,
+  normalizeStatusLookup,
+  scopedStatusMap,
+  svnDiff
+} from "./readonly.js";
+
+export async function svnPrecommit(input: { cwd?: string; paths: string[]; lineLimit?: number }): Promise<ToolEnvelope> {
+  const explicitError = requireExplicitPaths(input.paths);
+  const cwd = resolveCwd(input.cwd);
+  if (explicitError) {
+    return {
+      ...failEnvelope("svn_precommit", cwd, explicitError),
+      verdict: "GUARD_BLOCKED",
+      per_file: [],
+      risk_signals: [],
+      diff_excerpt: ""
+    };
+  }
+
+  const context = await getWcContext(input.cwd, input.paths);
+  if (!context.ok) {
+    return {
+      ...context.envelope,
+      verdict: "GUARD_BLOCKED",
+      per_file: [],
+      risk_signals: [],
+      diff_excerpt: ""
+    };
+  }
+
+  const resolved = resolveTargetsInsideWc(context.cwd, context.wcRoot, input.paths);
+  if (!resolved.ok) {
+    return {
+      ...failEnvelope("svn_precommit", context.cwd, resolved.note),
+      verdict: "GUARD_BLOCKED",
+      per_file: [],
+      risk_signals: [],
+      diff_excerpt: ""
+    };
+  }
+
+  const status = await scopedStatusMap(context.cwd, context.wcRoot, input.paths);
+  if (!status.envelope.ok) {
+    return {
+      ...status.envelope,
+      verdict: "GUARD_BLOCKED",
+      per_file: [],
+      risk_signals: [],
+      diff_excerpt: ""
+    };
+  }
+
+  const diff = await svnDiff({
+    cwd: context.cwd,
+    paths: input.paths,
+    ignoreEol: true,
+    lineLimit: input.lineLimit ?? defaultDiffLineLimit()
+  });
+  const eol = await eolCheck({ cwd: context.cwd, paths: input.paths });
+  const eolFiles = new Map(
+    ((eol.files as Array<{ path: string }> | undefined) ?? []).map((file) => [path.resolve(file.path).toLowerCase(), file])
+  );
+  const diffFiles = new Map(diff.per_file.map((file) => [path.resolve(context.cwd, file.path).toLowerCase(), file]));
+  const riskSignals = dryRiskSignals(resolved.paths, context.wcRoot, status.map);
+  const perFile = [];
+  const guardNotes: string[] = [];
+  const diffNotes: string[] = [];
+  let hasRealChange = false;
+  let needsEolFix = false;
+
+  if (!diff.ok) {
+    diffNotes.push(`svn diff failed: ${diff.note || "unknown reason"}`);
+    if (diff.recovery_tool === "eol_fix_verified") {
+      needsEolFix = true;
+    }
+  }
+
+  for (const target of resolved.paths) {
+    const lower = target.toLowerCase();
+    const statusCode = normalizeStatusLookup(status.map, target);
+    const diffFile = diffFiles.get(lower);
+    const eolFile = eolFiles.get(lower) as
+      | { kind?: string; eol_style?: string | null; has_bom?: boolean; mismatch?: boolean }
+      | undefined;
+    const never = neverCommitHit(target, context.wcRoot);
+    const guard = never
+      ? neverCommitNote(never, target, context.wcRoot)
+      : !statusCode || statusCode === "?" || statusCode === "!" || statusCode === "I"
+        ? `path is not committable: ${repoRelativePath(target, context.wcRoot)}`
+        : null;
+
+    if (guard) {
+      guardNotes.push(guard);
+    }
+
+    const pureEolChurn = statusCode === "M" && !diffFile;
+    if (eolFile?.mismatch || pureEolChurn) {
+      needsEolFix = true;
+    }
+    if (statusCode && statusCode !== "?" && statusCode !== "!" && statusCode !== "I" && !pureEolChurn) {
+      hasRealChange = true;
+    }
+
+    perFile.push({
+      path: repoRelativePath(target, context.wcRoot),
+      status: statusCode ?? "",
+      added: diffFile?.added ?? 0,
+      removed: diffFile?.removed ?? 0,
+      eol: eolFile?.kind ?? null,
+      eol_style: eolFile?.eol_style ?? null,
+      bom: eolFile?.has_bom ?? false,
+      pure_eol_churn: pureEolChurn,
+      guard
+    });
+  }
+
+  const version = await runSvnVersion(context.cwd, context.cwd);
+  const mixedRevision = version.exitCode === 0 && version.stdout.includes(":");
+  const verdict = guardNotes.length > 0
+    ? "GUARD_BLOCKED"
+    : !diff.ok && diff.recovery_tool !== "eol_fix_verified"
+      ? "DIFF_FAILED"
+      : needsEolFix
+        ? "EOL_FIX_NEEDED"
+        : !hasRealChange
+          ? "NOTHING_TO_COMMIT"
+          : "READY";
+
+  const notes = [
+    verdict,
+    ...guardNotes,
+    ...diffNotes,
+    mixedRevision ? "mixed revision working copy" : ""
+  ].filter(Boolean);
+
+  return {
+    ...createEnvelope({
+      ok: verdict !== "GUARD_BLOCKED" && verdict !== "DIFF_FAILED",
+      command: "svn_precommit",
+      cwd: context.cwd,
+      changed_paths: status.envelope.changed_paths,
+      conflicts: status.envelope.conflicts,
+      truncated: diff.truncated,
+      note: notes.join("; ")
+    }),
+    verdict,
+    per_file: perFile,
+    risk_signals: riskSignals,
+    diff_excerpt: diff.diff_excerpt,
+    truncated: diff.truncated
+  };
+}
+
+export async function eolFixVerified(input: {
+  cwd?: string;
+  path: string;
+  target?: "crlf" | "lf";
+  removeBom?: boolean;
+  dryRun?: boolean;
+  allowLarge?: boolean;
+}): Promise<ToolEnvelope> {
+  const cwd = resolveCwd(input.cwd);
+  if (readonlyMode()) {
+    return failEnvelope("eol_fix_verified", cwd, "READONLY instance");
+  }
+
+  const context = await getWcContext(input.cwd, [input.path]);
+  if (!context.ok) {
+    return context.envelope;
+  }
+
+  const resolved = resolveTargetsInsideWc(context.cwd, context.wcRoot, [input.path]);
+  if (!resolved.ok) {
+    return failEnvelope("eol_fix_verified", context.cwd, resolved.note);
+  }
+
+  const filePath = resolved.paths[0]!;
+  const existsError = assertExistingTargets([filePath]);
+  if (existsError) {
+    return failEnvelope("eol_fix_verified", context.cwd, existsError);
+  }
+  if (!pathIsFile(filePath)) {
+    return failEnvelope("eol_fix_verified", context.cwd, `path is not a file: ${repoRelativePath(filePath, context.wcRoot)}`);
+  }
+
+  const before = await sniffEol(filePath);
+  if (isBinaryKind(before.kind)) {
+    return {
+      ...failEnvelope("eol_fix_verified", context.cwd, "binary file refused"),
+      before
+    };
+  }
+  if (before.kind === "skipped-too-large" && !input.allowLarge) {
+    return {
+      ...failEnvelope("eol_fix_verified", context.cwd, "file too large for EOL repair without allowLarge:true"),
+      before
+    };
+  }
+
+  const prop = await runSvn(["propget", "svn:eol-style", filePath], context.cwd);
+  const eolStyle = prop.exitCode === 0 ? prop.stdout.trim() || null : null;
+  const target = normalizeEolTarget(input.target, eolStyle);
+  const converter = converterForEolTarget(target);
+  if (input.dryRun) {
+    return {
+      ...createEnvelope({
+        ok: true,
+        command: "eol_fix_verified",
+        cwd: context.cwd,
+        note: `dry run: would convert to ${target}`
+      }),
+      before,
+      after: before,
+      target,
+      eol_style: eolStyle,
+      converter,
+      pure_eol_churn: false
+    };
+  }
+
+  const conversion = await convertEol({
+    filePath,
+    target,
+    removeBom: input.removeBom ?? true,
+    cwd: context.cwd
+  });
+  if (conversion.exitCode !== 0) {
+    return {
+      ...envelopeFromRun({
+        run: conversion,
+        ok: false,
+        note: noteFromRun(conversion)
+      }),
+      target,
+      eol_style: eolStyle,
+      converter,
+      before
+    };
+  }
+
+  const after = await sniffEol(filePath);
+  const diff = await svnDiff({ cwd: context.cwd, paths: [filePath], ignoreEol: true, lineLimit: defaultDiffLineLimit() });
+  const pureEolChurn = diff.ok && diff.diff_excerpt.trim() === "";
+
+  return {
+    ...envelopeFromRun({
+      run: conversion,
+      ok: true,
+      note: pureEolChurn ? "pure EOL churn verified" : "EOL fixed; content diff remains"
+    }),
+    before,
+    after,
+    target,
+    eol_style: eolStyle,
+    converter,
+    verification_command: diff.command,
+    diff_ignored_eol: true,
+    pure_eol_churn: pureEolChurn
+  };
+}
+
+function pathIsFile(filePath: string): boolean {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}