svn-agent-mcp 1.0.0

package/tests/parsers.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, it } from "@jest/globals";
+import { parseCommittedRevision } from "../src/parse/commitText.js";
+import { parseDiffText } from "../src/parse/diffText.js";
+import { parseInfoXml } from "../src/parse/infoXml.js";
+import { parseLogXml } from "../src/parse/logXml.js";
+import { parseStatusXml } from "../src/parse/statusXml.js";
+import { parseUpdateText } from "../src/parse/updateText.js";
+
+describe("SVN text and XML parsers", () => {
+  it("counts per-file diff additions and removals without counting headers", () => {
+    const diff = parseDiffText(
+      [
+        "Index: src/example.ts",
+        "===================================================================",
+        "--- src/example.ts\t(revision 1)",
+        "+++ src/example.ts\t(working copy)",
+        "@@ -1,2 +1,3 @@",
+        " keep",
+        "-old",
+        "+new",
+        "+extra"
+      ].join("\n"),
+      4
+    );
+
+    expect(diff.per_file).toEqual([{ path: "src/example.ts", added: 2, removed: 1, binary: false }]);
+    expect(diff.truncated).toBe(true);
+  });
+
+  it("parses status XML into changed paths and conflicts", () => {
+    const parsed = parseStatusXml(`<?xml version="1.0"?>
+<status>
+  <target path=".">
+    <entry path="src/a.ts"><wc-status item="modified" revision="1" /></entry>
+    <entry path="src/b.ts"><wc-status item="conflicted" revision="1" tree-conflicted="true" /></entry>
+    <entry path="src/props.txt"><wc-status item="normal" props="modified" /></entry>
+    <entry path="src/prop-conflict.txt"><wc-status item="normal" props="conflicted" /></entry>
+  </target>
+</status>`);
+
+    expect(parsed.changed_paths).toEqual([
+      { status: "M", path: "src/a.ts" },
+      { status: "C", path: "src/b.ts" },
+      { status: "_M", path: "src/props.txt" },
+      { status: "C", path: "src/prop-conflict.txt" }
+    ]);
+    expect(parsed.conflicts).toEqual([
+      { path: "src/b.ts", type: "text" },
+      { path: "src/b.ts", type: "tree" },
+      { path: "src/prop-conflict.txt", type: "prop" }
+    ]);
+  });
+
+  it("parses svn info XML", () => {
+    const parsed = parseInfoXml(`<?xml version="1.0"?>
+<info>
+  <entry kind="dir" path="." revision="7">
+    <url>file:///repo/trunk</url>
+    <repository><root>file:///repo</root></repository>
+    <wc-info><wcroot-abspath>C:\\work\\repo</wcroot-abspath></wc-info>
+  </entry>
+</info>`);
+
+    expect(parsed[0]).toEqual({
+      url: "file:///repo/trunk",
+      repo_root: "file:///repo",
+      wc_root: "C:\\work\\repo",
+      revision: 7
+    });
+  });
+
+  it("uses null for info XML entries without a working-copy root", () => {
+    const parsed = parseInfoXml(`<?xml version="1.0"?>
+<info>
+  <entry kind="dir" path="." revision="7">
+    <url>file:///repo/trunk</url>
+    <repository><root>file:///repo</root></repository>
+  </entry>
+</info>`);
+
+    expect(parsed[0]?.wc_root).toBeNull();
+  });
+
+  it("ignores svn update informational lines instead of parsing phantom paths", () => {
+    const parsed = parseUpdateText(
+      [
+        "Updating '.':",
+        "U    src/a.ts",
+        "Restored 'src/gone.ts'",
+        "External at revision 41.",
+        "At revision 42.",
+        "Updated to revision 42."
+      ].join("\n")
+    );
+
+    expect(parsed.changed_paths).toEqual([{ status: "U", path: "src/a.ts" }]);
+    expect(parsed.conflicts).toEqual([]);
+  });
+
+  it("parses log XML and commit/update text", () => {
+    expect(parseCommittedRevision("Committed revision 42.")).toBe(42);
+    expect(parseUpdateText("U    src/a.ts\nC    src/b.ts\n   C src/tree.ts\nSummary of conflicts:\n  Tree conflicts: 2\n").conflicts).toEqual([
+      { path: "src/b.ts", type: "text" },
+      { path: "src/tree.ts", type: "tree" },
+      { path: "", type: "tree" }
+    ]);
+    expect(
+      parseLogXml(`<log><logentry revision="9"><author>a</author><date>d</date><msg>m</msg><paths><path action="M">/trunk/a</path></paths></logentry></log>`)
+    ).toEqual([
+      {
+        rev: 9,
+        author: "a",
+        date: "d",
+        msg: "m",
+        changed_paths: [{ status: "M", path: "/trunk/a" }]
+      }
+    ]);
+  });
+});

package/tests/runner.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, it } from "@jest/globals";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  dos2UnixExecutable,
+  runExecutable,
+  runExecutableStreamingLines,
+  runSvn,
+  svnAdminExecutable,
+  svnExecutable,
+  svnVersionExecutable
+} from "../src/runner.js";
+
+describe("runner executable resolution", () => {
+  it("prefers bundled binaries when no explicit environment override is set", () => {
+    withCleanToolEnv(() => {
+      const bin = path.join(process.cwd(), "bin");
+
+      expect(path.normalize(svnExecutable())).toBe(path.join(bin, "svn.exe"));
+      expect(path.normalize(svnVersionExecutable())).toBe(path.join(bin, "svnversion.exe"));
+      expect(path.normalize(svnAdminExecutable())).toBe(path.join(bin, "svnadmin.exe"));
+      expect(path.normalize(dos2UnixExecutable("dos2unix"))).toBe(path.join(bin, "dos2unix.exe"));
+      expect(path.normalize(dos2UnixExecutable("unix2dos"))).toBe(path.join(bin, "unix2dos.exe"));
+    });
+  });
+
+  it("keeps explicit environment overrides ahead of the bundled bin", () => {
+    withCleanToolEnv(() => {
+      const svn = path.join("C:", "custom", "svn.exe");
+      const eol = path.join("C:", "custom-eol");
+
+      process.env.SVN_AGENT_SVN_PATH = svn;
+      process.env.SVN_AGENT_DOS2UNIX_DIR = eol;
+
+      expect(path.normalize(svnExecutable())).toBe(svn);
+      expect(path.normalize(svnVersionExecutable())).toBe(path.join(path.dirname(svn), "svnversion.exe"));
+      expect(path.normalize(svnAdminExecutable())).toBe(path.join(path.dirname(svn), "svnadmin.exe"));
+      expect(path.normalize(dos2UnixExecutable("dos2unix"))).toBe(path.join(eol, "dos2unix.exe"));
+      expect(path.normalize(dos2UnixExecutable("unix2dos"))).toBe(path.join(eol, "unix2dos.exe"));
+    });
+  });
+
+  it("supports a portable bundled-bin directory override", () => {
+    withCleanToolEnv(() => {
+      const dir = fs.mkdtempSync(path.join(os.tmpdir(), "svn-agent-bin-"));
+      try {
+        for (const executable of ["svn.exe", "svnversion.exe", "svnadmin.exe", "dos2unix.exe", "unix2dos.exe"]) {
+          fs.writeFileSync(path.join(dir, executable), "");
+        }
+
+        process.env.SVN_AGENT_BIN_DIR = dir;
+
+        expect(path.normalize(svnExecutable())).toBe(path.join(dir, "svn.exe"));
+        expect(path.normalize(svnVersionExecutable())).toBe(path.join(dir, "svnversion.exe"));
+        expect(path.normalize(svnAdminExecutable())).toBe(path.join(dir, "svnadmin.exe"));
+        expect(path.normalize(dos2UnixExecutable("dos2unix"))).toBe(path.join(dir, "dos2unix.exe"));
+        expect(path.normalize(dos2UnixExecutable("unix2dos"))).toBe(path.join(dir, "unix2dos.exe"));
+      } finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+      }
+    });
+  });
+
+  it("runs SVN commands non-interactively", async () => {
+    const run = await runSvn(["--version", "--quiet"], process.cwd());
+
+    expect(run.exitCode).toBe(0);
+    expect(run.args[0]).toBe("--non-interactive");
+    expect(run.command).toContain("--non-interactive");
+  });
+
+  it("forces a stable C locale for child tools", async () => {
+    const run = await runExecutable(process.execPath, ["-e", "process.stdout.write(process.env.LC_ALL || '')"], {
+      cwd: process.cwd()
+    });
+
+    expect(run.stdout).toBe("C");
+  });
+
+  it("falls back to latin1 when child output is not valid UTF-8", async () => {
+    const run = await runExecutable(process.execPath, ["-e", "process.stdout.write(Buffer.from([0xe9]))"], {
+      cwd: process.cwd()
+    });
+
+    expect(run.stdout).toBe("é");
+  });
+
+  it("caps streaming stderr and marks the run truncated", async () => {
+    const run = await runExecutableStreamingLines(
+      process.execPath,
+      ["-e", "process.stderr.write('x'.repeat(1000))"],
+      { cwd: process.cwd(), stderrMaxBuffer: 16 },
+      () => undefined
+    );
+
+    expect(run.exitCode).toBe(0);
+    expect(run.stderr.length).toBeLessThan(1000);
+    expect(run.stderr).toContain("[stderr truncated]");
+    expect(run.truncated).toBe(true);
+  });
+
+  it("falls back to latin1 for streamed stdout lines that are not valid UTF-8", async () => {
+    const lines: string[] = [];
+    const run = await runExecutableStreamingLines(
+      process.execPath,
+      ["-e", "process.stdout.write(Buffer.from([0x2b, 0xe9, 0x0a]))"],
+      { cwd: process.cwd() },
+      (line) => lines.push(line)
+    );
+
+    expect(run.exitCode).toBe(0);
+    expect(lines).toEqual(["+é"]);
+    expect(run.stdout).toBe("+é");
+  });
+
+  it("settles streaming calls on timeout", async () => {
+    const started = Date.now();
+    const run = await runExecutableStreamingLines(
+      process.execPath,
+      ["-e", "setInterval(() => {}, 1000)"],
+      { cwd: process.cwd(), timeout: 50 },
+      () => undefined
+    );
+
+    expect(Date.now() - started).toBeLessThan(2000);
+    expect(run.timedOut).toBe(true);
+    expect(run.exitCode).toBeNull();
+  });
+});
+
+function withCleanToolEnv(fn: () => void): void {
+  const saved = {
+    SVN_AGENT_BIN_DIR: process.env.SVN_AGENT_BIN_DIR,
+    SVN_AGENT_SVN_PATH: process.env.SVN_AGENT_SVN_PATH,
+    SVN_AGENT_DOS2UNIX_DIR: process.env.SVN_AGENT_DOS2UNIX_DIR
+  };
+
+  delete process.env.SVN_AGENT_BIN_DIR;
+  delete process.env.SVN_AGENT_SVN_PATH;
+  delete process.env.SVN_AGENT_DOS2UNIX_DIR;
+
+  try {
+    fn();
+  } finally {
+    restoreEnv("SVN_AGENT_BIN_DIR", saved.SVN_AGENT_BIN_DIR);
+    restoreEnv("SVN_AGENT_SVN_PATH", saved.SVN_AGENT_SVN_PATH);
+    restoreEnv("SVN_AGENT_DOS2UNIX_DIR", saved.SVN_AGENT_DOS2UNIX_DIR);
+  }
+}
+
+function restoreEnv(name: string, value: string | undefined): void {
+  if (value === undefined) {
+    delete process.env[name];
+    return;
+  }
+
+  process.env[name] = value;
+}

package/tests/selfcheck.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "@jest/globals";
+import { svnSelfCheck } from "../src/tools/selfcheck.js";
+
+describe("svn self-check", () => {
+  it("reports package version, current release pointer, and bundled payload counts", async () => {
+    const check = await svnSelfCheck({});
+
+    expect(check.ok).toBe(true);
+    expect(check.server_version).toMatch(/^\d+\.\d+\.\d+$/);
+    expect(check.package_version).toBe(check.server_version);
+    expect(check.current_release).toBe(`v${check.server_version}`);
+    expect(check.current_matches_package).toBe(true);
+    expect(check.bin_file_count).toBe(48);
+    expect(check.dist_file_count).toBeGreaterThanOrEqual(60);
+    expect(check.release_prepare_available).toBe(true);
+    expect(check.clean_uses_node).toBe(true);
+    expect(check.toolchain_ok).toBe(true);
+    expect(check.startup_probe.svn.ok).toBe(true);
+    expect(check.startup_probe.dos2unix.ok).toBe(true);
+    expect(check.startup_probe.unix2dos.ok).toBe(true);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "types": ["node"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitOverride": true,
+    "allowSyntheticDefaultImports": true,
+    "isolatedModules": true,
+    "incremental": false,
+    "tsBuildInfoFile": ".tsbuildinfo"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "releases", "tests"]
+}