@massapi/svn-mcp 1.0.0

package/.cnb.yml

@@ -0,0 +1,43 @@
+# .cnb.yml
+$:
+  tag_push:
+    - docker:
+        image: node:22-alpine
+      imports:
+        - https://cnb.cool/massapi/keys/-/blob/main/github.yml
+      stages:
+        - name: update version
+          # 修改 package.json 中的version为当前tag，但不会提交代码
+          script: npm version $CNB_BRANCH --no-git-tag-version      
+        - name: build
+          image: node:20
+          script:
+            - npm ci
+            - npm run build
+        - name: npm publish
+          image: tencentcom/npm
+          settings:
+            # CNB_TOKEN_USER_NAME, CNB_TOKEN，CNB_COMMITTER_EMAIL 为流水线自带环境变量
+            username: $CNB_TOKEN_USER_NAME
+            token: $CNB_TOKEN
+            email: $CNB_COMMITTER_EMAIL
+            registry: https://npm.cnb.cool/massapi/npm-repo/-/packages/
+            folder: ./
+            fail_on_version_conflict: true                        
+
+  vscode:
+    - runner:
+        cpus: 4     
+      docker:
+        image: docker.cnb.cool/massapi/default-dev-env        
+      imports: https://cnb.cool/massapi/keys/-/blob/main/agent.yml
+      env:
+        CNB_WELCOME_CMD: echo "Welcome to CNB"      
+      services:
+        - vscode
+        - docker
+      stages:      
+        - name: set-agent-env
+          script: chmod +x /scripts/set-agent-env.sh; /scripts/set-agent-env.sh
+        - name: ls
+          script: ls -la          

package/README.md

@@ -0,0 +1,94 @@
+# svn-mcp
+
+Node.js-based SVN MCP server using stdio transport. Connects to svnserve via the native svn:// protocol — no SVN CLI installation required. Exposes 1 MCP tool:
+* list_logs — Retrieves recent commit logs. Accepts 1 parameter `limit` (default: 10), representing the number of recent entries. Returns an array of objects, each containing author, date, message, revision, action, and file list.
+
+All code comments and messages are in English.
+Package name: @massapi/svn-mcp
+
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| SVN_URL | SVN repository URL, e.g. `svn://svn.example.com/repo/project/trunk` |
+| SVN_USER | SVN username (optional for anonymous access) |
+| SVN_PASSWORD | SVN password (optional for anonymous access) |
+
+## Run
+
+```bash
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Start service
+SVN_URL=svn://your-svn-host/repo/path SVN_USER=your-user SVN_PASSWORD=your-password npm start
+```
+
+## Install
+
+```bash
+npm install
+npm run build
+```
+
+### Publish to npm
+
+```bash
+npm config set //registry.npmjs.org/:_authToken=npm_token
+npm publish --access public --loglevel verbose
+```
+
+## Inspector Test
+
+```bash
+SVN_URL=svn://your-svn-host/repo/path SVN_USER=your-user SVN_PASSWORD=your-password npm run inspect
+```
+
+This opens the Inspector UI in your browser for interactive MCP tool testing.
+
+### Inspector CLI Test
+
+```bash
+npm config set registry https://registry.npmjs.org/
+
+npx -y -p @massapi/svn-mcp -p @modelcontextprotocol/inspector mcp-inspector --cli \
+  -e SVN_URL=svn://svn.example.com/repo/project/trunk \
+  -e SVN_USER=admin \
+  -e SVN_PASSWORD=your-password \
+  svn-mcp \
+  --method tools/call \
+  --tool-name list_logs
+
+npx -y -p @massapi/svn-mcp -p @modelcontextprotocol/inspector mcp-inspector --cli \
+  -e SVN_URL=svn://svn.example.com/repo/project/trunk \
+  -e SVN_USER=admin \
+  -e SVN_PASSWORD=your-password \
+  svn-mcp \
+  --method tools/call \
+  --tool-name list_logs \
+  --tool-arg limit=5
+```
+
+## Configure in Claude Desktop
+
+Add to your Claude Desktop config file:
+
+```json
+{
+  "mcpServers": {
+    "svn": {
+      "command": "node",
+      "args": ["/path/to/svn-mcp/dist/index.js"],
+      "env": {
+        "SVN_URL": "svn://svn.example.com/repo/project/trunk",
+        "SVN_USER": "your-username",
+        "SVN_PASSWORD": "your-password"
+      }
+    }
+  }
+}
+```

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { fetchSvnLogs } from "./svn-protocol.js";
+// SVN server configuration via environment variables
+// SVN_URL format: svn://host:port/repo/path
+const SVN_URL = process.env.SVN_URL || "";
+const SVN_USER = process.env.SVN_USER || "";
+const SVN_PASSWORD = process.env.SVN_PASSWORD || "";
+/** Parse svn:// URL into host, port, path components. */
+function parseSvnUrl(url) {
+    const parsed = new URL(url);
+    return {
+        host: parsed.hostname,
+        port: parsed.port ? Number(parsed.port) : 3690,
+        path: parsed.pathname,
+    };
+}
+async function main() {
+    const server = new McpServer({
+        name: "svn-mcp",
+        version: "1.0.0",
+    });
+    server.tool("list_logs", "Get recent SVN commit logs via native svn:// protocol", { limit: z.number().default(10).describe("Number of recent commits to retrieve") }, async ({ limit }) => {
+        const { host, port, path } = parseSvnUrl(SVN_URL);
+        const logs = await fetchSvnLogs(host, port, SVN_USER, SVN_PASSWORD, path, limit);
+        return {
+            content: [{ type: "text", text: JSON.stringify(logs, null, 2) }],
+        };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error("Failed to start svn-mcp:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/svn-protocol.d.ts

@@ -0,0 +1,61 @@
+import * as net from "node:net";
+export type SvnItem = string | number | SvnItem[];
+/**
+ * Streaming reader for the SVN ra_svn wire protocol.
+ */
+export declare class SvnRaReader {
+    private buf;
+    private resolver;
+    constructor(socket: net.Socket);
+    private recv;
+    /** Ensure at least n chars in buffer. */
+    private ensure;
+    /** Skip whitespace. */
+    private skipWs;
+    /** Peek at next non-whitespace char. */
+    private peek;
+    /** Read one ra_svn item. */
+    readItem(): Promise<SvnItem>;
+    readWord(): Promise<string>;
+    readNumber(): Promise<number>;
+    readString(): Promise<string>;
+    readList(): Promise<SvnItem[]>;
+    /** Read a top-level response: either a list `( cmd ... )` or the word `done`. */
+    readResponse(): Promise<{
+        cmd: string;
+        params: SvnItem[];
+    }>;
+}
+export interface LogEntry {
+    revision: number;
+    author: string;
+    date: string;
+    message: string;
+    files: {
+        path: string;
+        action: string;
+        kind: string;
+    }[];
+}
+export declare class SvnRaClient {
+    private host;
+    private port;
+    private user;
+    private password;
+    private repoPath;
+    private socket;
+    private reader;
+    private connected;
+    constructor(host: string, port: number, user: string, password: string, repoPath: string);
+    connect(): Promise<void>;
+    private doCramMd5;
+    getLogs(limit: number): Promise<LogEntry[]>;
+    disconnect(): void;
+    private send;
+    private findMechs;
+    private findChallenge;
+    /** Extract revision number from ( success ( N ) ) response. */
+    private extractRev;
+    private parseLogEntry;
+}
+export declare function fetchSvnLogs(host: string, port: number, user: string, password: string, repoPath: string, limit: number): Promise<LogEntry[]>;

package/dist/svn-protocol.js

@@ -0,0 +1,366 @@
+import * as net from "node:net";
+import * as crypto from "node:crypto";
+/**
+ * Streaming reader for the SVN ra_svn wire protocol.
+ */
+export class SvnRaReader {
+    buf = "";
+    resolver = null;
+    constructor(socket) {
+        socket.on("data", (data) => {
+            const chunk = data.toString("utf-8");
+            if (this.resolver) {
+                const r = this.resolver;
+                this.resolver = null;
+                r(chunk);
+            }
+            else {
+                this.buf += chunk;
+            }
+        });
+    }
+    async recv() {
+        return new Promise((resolve) => { this.resolver = resolve; });
+    }
+    /** Ensure at least n chars in buffer. */
+    async ensure(n) {
+        while (this.buf.length < n) {
+            this.buf += await this.recv();
+        }
+    }
+    /** Skip whitespace. */
+    async skipWs() {
+        for (;;) {
+            await this.ensure(1);
+            if (this.buf[0] === " " || this.buf[0] === "\n" || this.buf[0] === "\r") {
+                this.buf = this.buf.slice(1);
+            }
+            else {
+                return;
+            }
+        }
+    }
+    /** Peek at next non-whitespace char. */
+    async peek() {
+        await this.skipWs();
+        await this.ensure(1);
+        return this.buf[0];
+    }
+    /** Read one ra_svn item. */
+    async readItem() {
+        const ch = await this.peek();
+        if (ch === "(")
+            return this.readList();
+        if (ch >= "0" && ch <= "9") {
+            // Look ahead to distinguish string (N:data) from number
+            await this.ensure(2);
+            for (let i = 0; i < this.buf.length; i++) {
+                const c = this.buf[i];
+                if (c === ":")
+                    return this.readString();
+                if (c === " " || c === "\n" || c === "\r" || c === ")")
+                    return this.readNumber();
+                if (c < "0" || c > "9")
+                    return this.readNumber();
+            }
+            return this.readNumber();
+        }
+        return this.readWord();
+    }
+    async readWord() {
+        await this.skipWs();
+        let word = "";
+        for (;;) {
+            await this.ensure(1);
+            const c = this.buf[0];
+            if (/[A-Za-z0-9_-]/.test(c)) {
+                word += c;
+                this.buf = this.buf.slice(1);
+            }
+            else {
+                return word;
+            }
+        }
+    }
+    async readNumber() {
+        await this.skipWs();
+        let digits = "";
+        for (;;) {
+            await this.ensure(1);
+            const c = this.buf[0];
+            if (c >= "0" && c <= "9") {
+                digits += c;
+                this.buf = this.buf.slice(1);
+            }
+            else {
+                return Number(digits);
+            }
+        }
+    }
+    async readString() {
+        await this.skipWs();
+        let lenStr = "";
+        for (;;) {
+            await this.ensure(1);
+            if (this.buf[0] === ":") {
+                this.buf = this.buf.slice(1);
+                break;
+            }
+            lenStr += this.buf[0];
+            this.buf = this.buf.slice(1);
+        }
+        const len = Number(lenStr);
+        while (Buffer.byteLength(this.buf, "utf-8") < len) {
+            this.buf += await this.recv();
+        }
+        const raw = Buffer.from(this.buf, "utf-8");
+        const str = raw.toString("utf-8", 0, len);
+        this.buf = raw.toString("utf-8", len);
+        return str;
+    }
+    async readList() {
+        await this.skipWs();
+        await this.ensure(1);
+        if (this.buf[0] !== "(")
+            throw new Error(`Expected '(' got '${this.buf[0]}'`);
+        this.buf = this.buf.slice(1);
+        const items = [];
+        for (;;) {
+            const ch = await this.peek();
+            if (ch === ")") {
+                this.buf = this.buf.slice(1);
+                return items;
+            }
+            items.push(await this.readItem());
+        }
+    }
+    /** Read a top-level response: either a list `( cmd ... )` or the word `done`. */
+    async readResponse() {
+        const ch = await this.peek();
+        if (ch === "d") {
+            const word = await this.readWord();
+            return { cmd: word, params: [] };
+        }
+        const list = await this.readList();
+        if (list.length === 0)
+            return { cmd: "", params: [] };
+        if (typeof list[0] === "string") {
+            return { cmd: list[0], params: list.slice(1) };
+        }
+        return { cmd: "", params: list };
+    }
+}
+// ---------------------------------------------------------------------------
+// Encoder helpers
+// ---------------------------------------------------------------------------
+function w(word) { return word + " "; }
+function n(num) { return num + " "; }
+function s(str) { const b = Buffer.from(str, "utf-8"); return b.length + ":" + str + " "; }
+function b(val) { return val ? "true " : "false "; }
+export class SvnRaClient {
+    host;
+    port;
+    user;
+    password;
+    repoPath;
+    socket;
+    reader;
+    connected = false;
+    constructor(host, port, user, password, repoPath) {
+        this.host = host;
+        this.port = port;
+        this.user = user;
+        this.password = password;
+        this.repoPath = repoPath;
+    }
+    async connect() {
+        this.socket = await new Promise((resolve, reject) => {
+            const sock = net.createConnection({ host: this.host, port: this.port }, () => resolve(sock));
+            sock.on("error", reject);
+        });
+        this.reader = new SvnRaReader(this.socket);
+        this.connected = true;
+        // 1. Read server greeting
+        // ( success ( min max ( mechs ) ( cap1 cap2 ... ) ) )
+        await this.reader.readResponse();
+        // 2. Send client response: ( version ( caps ) url client-str ( ) )
+        const url = `svn://${this.host}${this.repoPath}`;
+        this.send("( 2 ( edit-pipeline svndiff1 absent-entries depth mergeinfo log-revprops ) " +
+            s(url) +
+            s("SVN/1.14.0") +
+            "( ) ) ");
+        // 3. Read auth request: ( success ( ( CRAM-MD5 ) realm ) )
+        const authResp = await this.reader.readResponse();
+        const mechs = this.findMechs(authResp.params);
+        if (mechs.length === 0) {
+            // No auth – server sends ( success ( ( ) 0: ) )
+        }
+        else if (mechs.includes("CRAM-MD5")) {
+            await this.doCramMd5();
+        }
+        else {
+            throw new Error("Unsupported auth: " + mechs.join(", "));
+        }
+        // 4. Read repos-info: ( success ( uuid url ( caps ) ) )
+        await this.reader.readResponse();
+    }
+    async doCramMd5() {
+        // Send: ( CRAM-MD5 ( ) )
+        this.send("( CRAM-MD5 ( ) ) ");
+        // Read challenge: ( step ( challenge-string ) )
+        const step = await this.reader.readResponse();
+        const challenge = this.findChallenge(step.params);
+        // Compute HMAC-MD5
+        const hmac = crypto.createHmac("md5", this.password);
+        hmac.update(challenge);
+        const hex = hmac.digest("hex");
+        const reply = `${this.user} ${hex}`;
+        // Send response as a BARE string (not wrapped in a tuple!)
+        this.send(s(reply));
+        // Read auth result: ( success ( ) )
+        const authResult = await this.reader.readResponse();
+        if (authResult.cmd !== "success") {
+            throw new Error("Auth failed: " + JSON.stringify(authResult));
+        }
+    }
+    async getLogs(limit) {
+        // First get the latest revision
+        this.send("( get-latest-rev ( ) ) ");
+        // trivial auth + response
+        await this.reader.readResponse();
+        const revResp = await this.reader.readResponse();
+        // Response is ( success ( N ) ), so revResp.params[0] is [N]
+        const latestRev = this.extractRev(revResp.params);
+        // ( log ( ( path ) ( start-rev ) ( end-rev ) changed-paths strict-node limit include-merged revprops ( revprop-names ) ) )
+        this.send("( log ( ( 0: ) ( " + n(latestRev) + ") ( 0 ) " +
+            b(true) + b(false) +
+            n(limit) + b(false) +
+            w("revprops") + " ( " +
+            s("svn:author") + s("svn:date") + s("svn:log") +
+            ") ) ) ");
+        // trivial auth
+        await this.reader.readResponse();
+        // Read log entries until "done"
+        const entries = [];
+        for (;;) {
+            const resp = await this.reader.readResponse();
+            if (resp.cmd === "done")
+                break;
+            entries.push(this.parseLogEntry(resp.params));
+        }
+        // Final: ( success ( ) )
+        await this.reader.readResponse();
+        return entries;
+    }
+    disconnect() {
+        if (this.connected) {
+            this.socket.destroy();
+            this.connected = false;
+        }
+    }
+    send(data) {
+        this.socket.write(data, "utf-8");
+    }
+    findMechs(params) {
+        const result = [];
+        const walk = (items) => {
+            for (const item of items) {
+                if (typeof item === "string" && /^[A-Z][A-Z0-9-]/.test(item)) {
+                    result.push(item);
+                }
+                else if (Array.isArray(item)) {
+                    walk(item);
+                }
+            }
+        };
+        walk(params);
+        return result;
+    }
+    findChallenge(params) {
+        const walk = (items) => {
+            for (const item of items) {
+                if (typeof item === "string" && item.includes("@"))
+                    return item;
+                if (Array.isArray(item)) {
+                    const r = walk(item);
+                    if (r)
+                        return r;
+                }
+            }
+            return "";
+        };
+        return walk(params);
+    }
+    /** Extract revision number from ( success ( N ) ) response. */
+    extractRev(params) {
+        for (const p of params) {
+            if (typeof p === "number")
+                return p;
+            if (Array.isArray(p)) {
+                const r = this.extractRev(p);
+                if (r > 0)
+                    return r;
+            }
+        }
+        return 0;
+    }
+    parseLogEntry(items) {
+        // Wire: ( ( changed-paths ) rev ( author ) ( date ) ( message ) has-children invalid-revnum revprop-count ( ) subtractive-merge )
+        let idx = 0;
+        // Changed paths
+        const files = [];
+        if (Array.isArray(items[idx])) {
+            const pathsList = items[idx];
+            for (const p of pathsList) {
+                if (Array.isArray(p)) {
+                    const e = p;
+                    // ( path action ( ) ( kind text-mods prop-mods ) )
+                    let kind = "";
+                    if (Array.isArray(e[3]) && typeof e[3][0] === "string") {
+                        kind = e[3][0];
+                    }
+                    files.push({
+                        path: typeof e[0] === "string" ? e[0] : "",
+                        action: typeof e[1] === "string" ? e[1] : "",
+                        kind,
+                    });
+                }
+            }
+            idx++;
+        }
+        // Revision
+        const revision = typeof items[idx] === "number" ? items[idx] : 0;
+        idx++;
+        // ( author ) ( date ) ( message ) – each is a list with one string
+        const readOptStr = () => {
+            if (idx >= items.length)
+                return "";
+            const item = items[idx++];
+            if (typeof item === "string")
+                return item;
+            if (Array.isArray(item) && item.length === 1 && typeof item[0] === "string")
+                return item[0];
+            if (Array.isArray(item) && item.length === 0)
+                return "";
+            return "";
+        };
+        const author = readOptStr();
+        const date = readOptStr();
+        const message = readOptStr();
+        return { revision, author, date, message, files };
+    }
+}
+// ---------------------------------------------------------------------------
+// Convenience
+// ---------------------------------------------------------------------------
+export async function fetchSvnLogs(host, port, user, password, repoPath, limit) {
+    const client = new SvnRaClient(host, port, user, password, repoPath);
+    try {
+        await client.connect();
+        return await client.getLogs(limit);
+    }
+    finally {
+        client.disconnect();
+    }
+}
+//# sourceMappingURL=svn-protocol.js.map

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@massapi/svn-mcp",
+  "version": "1.0.0",
+  "description": "SVN MCP server based on Node.js, using native svn:// protocol via stdio transport",
+  "main": "dist/index.js",
+  "bin": {
+    "svn-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "inspect": "npx @modelcontextprotocol/inspector node dist/index.js"
+  },
+  "type": "module",
+  "keywords": ["svn", "mcp"],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "typescript": "^5.7.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { fetchSvnLogs } from "./svn-protocol.js";
+
+// SVN server configuration via environment variables
+// SVN_URL format: svn://host:port/repo/path
+const SVN_URL = process.env.SVN_URL || "";
+const SVN_USER = process.env.SVN_USER || "";
+const SVN_PASSWORD = process.env.SVN_PASSWORD || "";
+
+/** Parse svn:// URL into host, port, path components. */
+function parseSvnUrl(url: string): { host: string; port: number; path: string } {
+  const parsed = new URL(url);
+  return {
+    host: parsed.hostname,
+    port: parsed.port ? Number(parsed.port) : 3690,
+    path: parsed.pathname,
+  };
+}
+
+async function main() {
+  const server = new McpServer({
+    name: "svn-mcp",
+    version: "1.0.0",
+  });
+
+  server.tool(
+    "list_logs",
+    "Get recent SVN commit logs via native svn:// protocol",
+    { limit: z.number().default(10).describe("Number of recent commits to retrieve") },
+    async ({ limit }) => {
+      const { host, port, path } = parseSvnUrl(SVN_URL);
+      const logs = await fetchSvnLogs(host, port, SVN_USER, SVN_PASSWORD, path, limit);
+      return {
+        content: [{ type: "text", text: JSON.stringify(logs, null, 2) }],
+      };
+    }
+  );
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  console.error("Failed to start svn-mcp:", err);
+  process.exit(1);
+});

package/src/svn-protocol.ts

@@ -0,0 +1,412 @@
+import * as net from "node:net";
+import * as crypto from "node:crypto";
+
+// ---------------------------------------------------------------------------
+// SVN RA (ra_svn) wire protocol – framing, auth, and log retrieval
+// ---------------------------------------------------------------------------
+
+export type SvnItem = string | number | SvnItem[];
+
+/**
+ * Streaming reader for the SVN ra_svn wire protocol.
+ */
+export class SvnRaReader {
+  private buf = "";
+  private resolver: ((chunk: string) => void) | null = null;
+
+  constructor(socket: net.Socket) {
+    socket.on("data", (data: Buffer) => {
+      const chunk = data.toString("utf-8");
+      if (this.resolver) {
+        const r = this.resolver;
+        this.resolver = null;
+        r(chunk);
+      } else {
+        this.buf += chunk;
+      }
+    });
+  }
+
+  private async recv(): Promise<string> {
+    return new Promise<string>((resolve) => { this.resolver = resolve; });
+  }
+
+  /** Ensure at least n chars in buffer. */
+  private async ensure(n: number): Promise<void> {
+    while (this.buf.length < n) {
+      this.buf += await this.recv();
+    }
+  }
+
+  /** Skip whitespace. */
+  private async skipWs(): Promise<void> {
+    for (;;) {
+      await this.ensure(1);
+      if (this.buf[0] === " " || this.buf[0] === "\n" || this.buf[0] === "\r") {
+        this.buf = this.buf.slice(1);
+      } else {
+        return;
+      }
+    }
+  }
+
+  /** Peek at next non-whitespace char. */
+  private async peek(): Promise<string> {
+    await this.skipWs();
+    await this.ensure(1);
+    return this.buf[0];
+  }
+
+  /** Read one ra_svn item. */
+  async readItem(): Promise<SvnItem> {
+    const ch = await this.peek();
+    if (ch === "(") return this.readList();
+    if (ch >= "0" && ch <= "9") {
+      // Look ahead to distinguish string (N:data) from number
+      await this.ensure(2);
+      for (let i = 0; i < this.buf.length; i++) {
+        const c = this.buf[i];
+        if (c === ":") return this.readString();
+        if (c === " " || c === "\n" || c === "\r" || c === ")") return this.readNumber();
+        if (c < "0" || c > "9") return this.readNumber();
+      }
+      return this.readNumber();
+    }
+    return this.readWord();
+  }
+
+  async readWord(): Promise<string> {
+    await this.skipWs();
+    let word = "";
+    for (;;) {
+      await this.ensure(1);
+      const c = this.buf[0];
+      if (/[A-Za-z0-9_-]/.test(c)) {
+        word += c;
+        this.buf = this.buf.slice(1);
+      } else {
+        return word;
+      }
+    }
+  }
+
+  async readNumber(): Promise<number> {
+    await this.skipWs();
+    let digits = "";
+    for (;;) {
+      await this.ensure(1);
+      const c = this.buf[0];
+      if (c >= "0" && c <= "9") {
+        digits += c;
+        this.buf = this.buf.slice(1);
+      } else {
+        return Number(digits);
+      }
+    }
+  }
+
+  async readString(): Promise<string> {
+    await this.skipWs();
+    let lenStr = "";
+    for (;;) {
+      await this.ensure(1);
+      if (this.buf[0] === ":") {
+        this.buf = this.buf.slice(1);
+        break;
+      }
+      lenStr += this.buf[0];
+      this.buf = this.buf.slice(1);
+    }
+    const len = Number(lenStr);
+    while (Buffer.byteLength(this.buf, "utf-8") < len) {
+      this.buf += await this.recv();
+    }
+    const raw = Buffer.from(this.buf, "utf-8");
+    const str = raw.toString("utf-8", 0, len);
+    this.buf = raw.toString("utf-8", len);
+    return str;
+  }
+
+  async readList(): Promise<SvnItem[]> {
+    await this.skipWs();
+    await this.ensure(1);
+    if (this.buf[0] !== "(") throw new Error(`Expected '(' got '${this.buf[0]}'`);
+    this.buf = this.buf.slice(1);
+    const items: SvnItem[] = [];
+    for (;;) {
+      const ch = await this.peek();
+      if (ch === ")") {
+        this.buf = this.buf.slice(1);
+        return items;
+      }
+      items.push(await this.readItem());
+    }
+  }
+
+  /** Read a top-level response: either a list `( cmd ... )` or the word `done`. */
+  async readResponse(): Promise<{ cmd: string; params: SvnItem[] }> {
+    const ch = await this.peek();
+    if (ch === "d") {
+      const word = await this.readWord();
+      return { cmd: word, params: [] };
+    }
+    const list = await this.readList();
+    if (list.length === 0) return { cmd: "", params: [] };
+    if (typeof list[0] === "string") {
+      return { cmd: list[0] as string, params: list.slice(1) };
+    }
+    return { cmd: "", params: list };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Encoder helpers
+// ---------------------------------------------------------------------------
+
+function w(word: string): string { return word + " "; }
+function n(num: number): string { return num + " "; }
+function s(str: string): string { const b = Buffer.from(str, "utf-8"); return b.length + ":" + str + " "; }
+function b(val: boolean): string { return val ? "true " : "false "; }
+
+// ---------------------------------------------------------------------------
+// Client
+// ---------------------------------------------------------------------------
+
+export interface LogEntry {
+  revision: number;
+  author: string;
+  date: string;
+  message: string;
+  files: { path: string; action: string; kind: string }[];
+}
+
+export class SvnRaClient {
+  private socket!: net.Socket;
+  private reader!: SvnRaReader;
+  private connected = false;
+
+  constructor(
+    private host: string,
+    private port: number,
+    private user: string,
+    private password: string,
+    private repoPath: string
+  ) {}
+
+  async connect(): Promise<void> {
+    this.socket = await new Promise<net.Socket>((resolve, reject) => {
+      const sock = net.createConnection({ host: this.host, port: this.port }, () => resolve(sock));
+      sock.on("error", reject);
+    });
+    this.reader = new SvnRaReader(this.socket);
+    this.connected = true;
+
+    // 1. Read server greeting
+    // ( success ( min max ( mechs ) ( cap1 cap2 ... ) ) )
+    await this.reader.readResponse();
+
+    // 2. Send client response: ( version ( caps ) url client-str ( ) )
+    const url = `svn://${this.host}${this.repoPath}`;
+    this.send(
+      "( 2 ( edit-pipeline svndiff1 absent-entries depth mergeinfo log-revprops ) " +
+      s(url) +
+      s("SVN/1.14.0") +
+      "( ) ) "
+    );
+
+    // 3. Read auth request: ( success ( ( CRAM-MD5 ) realm ) )
+    const authResp = await this.reader.readResponse();
+    const mechs = this.findMechs(authResp.params);
+
+    if (mechs.length === 0) {
+      // No auth – server sends ( success ( ( ) 0: ) )
+    } else if (mechs.includes("CRAM-MD5")) {
+      await this.doCramMd5();
+    } else {
+      throw new Error("Unsupported auth: " + mechs.join(", "));
+    }
+
+    // 4. Read repos-info: ( success ( uuid url ( caps ) ) )
+    await this.reader.readResponse();
+  }
+
+  private async doCramMd5(): Promise<void> {
+    // Send: ( CRAM-MD5 ( ) )
+    this.send("( CRAM-MD5 ( ) ) ");
+
+    // Read challenge: ( step ( challenge-string ) )
+    const step = await this.reader.readResponse();
+    const challenge = this.findChallenge(step.params);
+
+    // Compute HMAC-MD5
+    const hmac = crypto.createHmac("md5", this.password);
+    hmac.update(challenge);
+    const hex = hmac.digest("hex");
+    const reply = `${this.user} ${hex}`;
+
+    // Send response as a BARE string (not wrapped in a tuple!)
+    this.send(s(reply));
+
+    // Read auth result: ( success ( ) )
+    const authResult = await this.reader.readResponse();
+    if (authResult.cmd !== "success") {
+      throw new Error("Auth failed: " + JSON.stringify(authResult));
+    }
+  }
+
+  async getLogs(limit: number): Promise<LogEntry[]> {
+    // First get the latest revision
+    this.send("( get-latest-rev ( ) ) ");
+    // trivial auth + response
+    await this.reader.readResponse();
+    const revResp = await this.reader.readResponse();
+    // Response is ( success ( N ) ), so revResp.params[0] is [N]
+    const latestRev = this.extractRev(revResp.params);
+
+    // ( log ( ( path ) ( start-rev ) ( end-rev ) changed-paths strict-node limit include-merged revprops ( revprop-names ) ) )
+    this.send(
+      "( log ( ( 0: ) ( " + n(latestRev) + ") ( 0 ) " +
+      b(true) + b(false) +
+      n(limit) + b(false) +
+      w("revprops") + " ( " +
+      s("svn:author") + s("svn:date") + s("svn:log") +
+      ") ) ) "
+    );
+
+    // trivial auth
+    await this.reader.readResponse();
+
+    // Read log entries until "done"
+    const entries: LogEntry[] = [];
+    for (;;) {
+      const resp = await this.reader.readResponse();
+      if (resp.cmd === "done") break;
+      entries.push(this.parseLogEntry(resp.params));
+    }
+
+    // Final: ( success ( ) )
+    await this.reader.readResponse();
+
+    return entries;
+  }
+
+  disconnect(): void {
+    if (this.connected) {
+      this.socket.destroy();
+      this.connected = false;
+    }
+  }
+
+  private send(data: string): void {
+    this.socket.write(data, "utf-8");
+  }
+
+  private findMechs(params: SvnItem[]): string[] {
+    const result: string[] = [];
+    const walk = (items: SvnItem[]): void => {
+      for (const item of items) {
+        if (typeof item === "string" && /^[A-Z][A-Z0-9-]/.test(item)) {
+          result.push(item);
+        } else if (Array.isArray(item)) {
+          walk(item);
+        }
+      }
+    };
+    walk(params);
+    return result;
+  }
+
+  private findChallenge(params: SvnItem[]): string {
+    const walk = (items: SvnItem[]): string => {
+      for (const item of items) {
+        if (typeof item === "string" && item.includes("@")) return item;
+        if (Array.isArray(item)) {
+          const r = walk(item);
+          if (r) return r;
+        }
+      }
+      return "";
+    };
+    return walk(params);
+  }
+
+  /** Extract revision number from ( success ( N ) ) response. */
+  private extractRev(params: SvnItem[]): number {
+    for (const p of params) {
+      if (typeof p === "number") return p;
+      if (Array.isArray(p)) {
+        const r = this.extractRev(p);
+        if (r > 0) return r;
+      }
+    }
+    return 0;
+  }
+
+  private parseLogEntry(items: SvnItem[]): LogEntry {
+    // Wire: ( ( changed-paths ) rev ( author ) ( date ) ( message ) has-children invalid-revnum revprop-count ( ) subtractive-merge )
+    let idx = 0;
+
+    // Changed paths
+    const files: { path: string; action: string; kind: string }[] = [];
+    if (Array.isArray(items[idx])) {
+      const pathsList = items[idx] as SvnItem[];
+      for (const p of pathsList) {
+        if (Array.isArray(p)) {
+          const e = p as SvnItem[];
+          // ( path action ( ) ( kind text-mods prop-mods ) )
+          let kind = "";
+          if (Array.isArray(e[3]) && typeof (e[3] as SvnItem[])[0] === "string") {
+            kind = (e[3] as SvnItem[])[0] as string;
+          }
+          files.push({
+            path: typeof e[0] === "string" ? e[0] : "",
+            action: typeof e[1] === "string" ? e[1] : "",
+            kind,
+          });
+        }
+      }
+      idx++;
+    }
+
+    // Revision
+    const revision = typeof items[idx] === "number" ? (items[idx] as number) : 0;
+    idx++;
+
+    // ( author ) ( date ) ( message ) – each is a list with one string
+    const readOptStr = (): string => {
+      if (idx >= items.length) return "";
+      const item = items[idx++];
+      if (typeof item === "string") return item;
+      if (Array.isArray(item) && item.length === 1 && typeof item[0] === "string") return item[0];
+      if (Array.isArray(item) && item.length === 0) return "";
+      return "";
+    };
+
+    const author = readOptStr();
+    const date = readOptStr();
+    const message = readOptStr();
+
+    return { revision, author, date, message, files };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Convenience
+// ---------------------------------------------------------------------------
+
+export async function fetchSvnLogs(
+  host: string,
+  port: number,
+  user: string,
+  password: string,
+  repoPath: string,
+  limit: number
+): Promise<LogEntry[]> {
+  const client = new SvnRaClient(host, port, user, password, repoPath);
+  try {
+    await client.connect();
+    return await client.getLogs(limit);
+  } finally {
+    client.disconnect();
+  }
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "sourceMap": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}