@daghis/teamcity-mcp 2.12.9 → 2.12.11

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [2.12.11](https://github.com/Daghis/teamcity-mcp/compare/teamcity-mcp-v2.12.10...teamcity-mcp-v2.12.11) (2026-10-28)
+
+
+### Bug Fixes
+
+* **build-log:** keep memory bounded for log chunks, tails and streams ([#549](https://github.com/Daghis/teamcity-mcp/issues/549)) ([7815ab1](https://github.com/Daghis/teamcity-mcp/commit/7815ab10a2b7a395a680d665ca68ebe52a7d629e))
+
+## [2.12.10](https://github.com/Daghis/teamcity-mcp/compare/teamcity-mcp-v2.12.9...teamcity-mcp-v2.12.10) (2026-10-21)
+
+
+### Bug Fixes
+
+* **security:** bump follow-redirects to 1.16.1 ([#547](https://github.com/Daghis/teamcity-mcp/issues/547)) ([cc52893](https://github.com/Daghis/teamcity-mcp/commit/cc5289336b3db586d054bbbbace74e4fcee9988d))
+
 ## [2.12.9](https://github.com/Daghis/teamcity-mcp/compare/teamcity-mcp-v2.12.8...teamcity-mcp-v2.12.9) (2026-10-20)
 
 

package/dist/index.js

@@ -68,11 +68,49 @@ async function* sliceLines(source, startLine, endLine) {
     }
   }
 }
-var import_stream, isReadableStream, destroyStream, discardStreamBody, toBuffer, sliceStreamLines;
+async function* readLines(source, keep = () => true) {
+  const decoder = new import_string_decoder.StringDecoder("utf8");
+  let pending = [];
+  let started = false;
+  let index = 0;
+  let afterCarriageReturn = false;
+  const append = (piece) => {
+    if (piece) {
+      started = true;
+      if (keep(index)) {
+        pending.push(piece);
+      }
+    }
+  };
+  for await (const raw of source) {
+    let text = decoder.write(toBuffer(raw));
+    if (afterCarriageReturn && text.startsWith("\n")) {
+      text = text.slice(1);
+    }
+    afterCarriageReturn = text.endsWith("\r");
+    const segments = text.split(LINE_BREAK);
+    const unfinished = segments.splice(-1).join("");
+    for (const segment of segments) {
+      append(segment);
+      const line = pending.join("");
+      pending = [];
+      started = false;
+      index += 1;
+      yield line;
+    }
+    append(unfinished);
+  }
+  append(decoder.end());
+  if (started) {
+    yield pending.join("");
+  }
+}
+var import_stream, import_string_decoder, isReadableStream, destroyStream, discardStreamBody, toBuffer, sliceStreamLines, LINE_BREAK, readLineRange, readLastLines;
 var init_stream = __esm({
   "src/teamcity/utils/stream.ts"() {
     "use strict";
     import_stream = require("stream");
+    import_string_decoder = require("string_decoder");
     isReadableStream = (value) => typeof value === "object" && value !== null && typeof value.pipe === "function" && typeof value.on === "function";
     destroyStream = (stream) => {
       stream.on("error", () => void 0);
@@ -104,6 +142,46 @@ var init_stream = __esm({
       };
       return slice;
     };
+    LINE_BREAK = /\r\n|\r|\n/;
+    readLineRange = async (source, startLine, lineCount) => {
+      const endLine = startLine + lineCount;
+      const lines = [];
+      let index = 0;
+      try {
+        const inRange = (line) => line >= startLine && line < endLine;
+        for await (const line of readLines(source, inRange)) {
+          if (index >= endLine) {
+            return { lines, startLine, nextStartLine: endLine };
+          }
+          if (index >= startLine) {
+            lines.push(line);
+          }
+          index += 1;
+        }
+      } finally {
+        destroyStream(source);
+      }
+      return { lines, startLine: Math.min(startLine, index), totalLines: index };
+    };
+    readLastLines = async (source, lineCount) => {
+      const window = [];
+      let totalLines = 0;
+      try {
+        for await (const line of readLines(source)) {
+          if (lineCount > 0) {
+            window[totalLines % lineCount] = line;
+          }
+          totalLines += 1;
+        }
+      } finally {
+        destroyStream(source);
+      }
+      if (totalLines <= lineCount) {
+        return { lines: window, totalLines };
+      }
+      const oldest = totalLines % lineCount;
+      return { lines: [...window.slice(oldest), ...window.slice(0, oldest)], totalLines };
+    };
   }
 });
 
@@ -1310,7 +1388,7 @@ function debug2(message, meta) {
 // package.json
 var package_default = {
   name: "@daghis/teamcity-mcp",
-  version: "2.12.9",
+  version: "2.12.11",
   description: "Model Control Protocol server for TeamCity CI/CD integration with AI coding assistants",
   mcpName: "io.github.Daghis/teamcity",
   main: "dist/index.js",
@@ -1415,7 +1493,7 @@ var package_default = {
     },
     axios: "^1.20.0",
     "body-parser": "^2.2.1",
-    "follow-redirects": "^1.16.0",
+    "follow-redirects": "^1.16.1",
     "glob@>=10.2.0 <10.5.0": "^10.5.0",
     hono: "^4.12.14",
     "lodash-es": "^4.18.0",
@@ -1427,7 +1505,7 @@ var package_default = {
 
 // src/tools.ts
 var import_node_crypto = require("node:crypto");
-var import_node_fs2 = require("node:fs");
+var import_node_fs3 = require("node:fs");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
 var import_promises = require("node:stream/promises");
@@ -4119,6 +4197,7 @@ function createAdapterFromTeamCityAPI(api, options = {}) {
     triggerBuild: (buildTypeId, branchName, comment) => api.triggerBuild(buildTypeId, branchName, comment),
     getBuildLog: (buildId) => api.getBuildLog(buildId),
     getBuildLogChunk: (buildId, options2) => api.getBuildLogChunk(buildId, options2),
+    getBuildLogTail: (buildId, lineCount) => api.getBuildLogTail(buildId, lineCount),
     listBuildTypes: (projectId) => api.listBuildTypes(projectId),
     getBuildType: (buildTypeId) => api.getBuildType(buildTypeId),
     listTestFailures: (buildId) => api.listTestFailures(buildId),
@@ -4280,6 +4359,75 @@ function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
+// src/utils/disk-space.ts
+var import_node_fs2 = require("node:fs");
+var import_node_stream = require("node:stream");
+var DEFAULT_MIN_FREE_DISK_BYTES = 1024 ** 3;
+var RECHECK_EVERY_BYTES = 64 * 1024 ** 2;
+var formatBytes = (bytes) => bytes >= 1024 ** 3 ? `${(bytes / 1024 ** 3).toFixed(2)} GiB` : `${(bytes / 1024 ** 2).toFixed(1)} MiB`;
+var InsufficientDiskSpaceError = class extends Error {
+  constructor(directory, freeBytes, minFreeBytes, requiredBytes) {
+    const need = requiredBytes === void 0 ? "" : `${formatBytes(requiredBytes)} needed, `;
+    super(
+      `Not enough disk space in ${directory}: ${need}${formatBytes(freeBytes)} free, at least ${formatBytes(minFreeBytes)} must stay free`
+    );
+    this.directory = directory;
+    this.freeBytes = freeBytes;
+    this.minFreeBytes = minFreeBytes;
+    this.requiredBytes = requiredBytes;
+    this.name = "InsufficientDiskSpaceError";
+  }
+  directory;
+  freeBytes;
+  minFreeBytes;
+  requiredBytes;
+};
+var getFreeDiskBytes = async (directory) => {
+  const stats = await import_node_fs2.promises.statfs(directory);
+  return stats.bavail * stats.bsize;
+};
+var assertDiskSpace = async (directory, requiredBytes = 0, minFreeBytes = DEFAULT_MIN_FREE_DISK_BYTES) => {
+  const freeBytes = await getFreeDiskBytes(directory);
+  if (freeBytes - requiredBytes < minFreeBytes) {
+    throw new InsufficientDiskSpaceError(
+      directory,
+      freeBytes,
+      minFreeBytes,
+      requiredBytes > 0 ? requiredBytes : void 0
+    );
+  }
+  return freeBytes;
+};
+var createDiskSpaceGuard = (directory, initialFreeBytes, minFreeBytes, recheckEveryBytes = RECHECK_EVERY_BYTES) => {
+  let written = 0;
+  let sinceCheck = 0;
+  let reportedFreeBytes = initialFreeBytes;
+  const estimatedFreeBytes = () => Math.min(reportedFreeBytes, initialFreeBytes - written);
+  return new import_node_stream.Transform({
+    transform(chunk, _encoding, callback) {
+      written += chunk.length;
+      sinceCheck += chunk.length;
+      if (estimatedFreeBytes() < minFreeBytes) {
+        callback(new InsufficientDiskSpaceError(directory, estimatedFreeBytes(), minFreeBytes));
+        return;
+      }
+      if (sinceCheck < recheckEveryBytes) {
+        callback(null, chunk);
+        return;
+      }
+      sinceCheck = 0;
+      getFreeDiskBytes(directory).then((freeBytes) => {
+        reportedFreeBytes = freeBytes;
+        if (estimatedFreeBytes() < minFreeBytes) {
+          callback(new InsufficientDiskSpaceError(directory, estimatedFreeBytes(), minFreeBytes));
+        } else {
+          callback(null, chunk);
+        }
+      }, callback);
+    }
+  });
+};
+
 // src/utils/list-builds-locator.ts
 var SIMPLE_BRANCH_VALUES = /* @__PURE__ */ new Set([
   "default:true",
@@ -4931,6 +5079,9 @@ axiosRetry.linearDelay = linearDelay;
 axiosRetry.isRetryableError = isRetryableError2;
 var esm_default = axiosRetry;
 
+// src/api-client.ts
+var import_stream4 = require("stream");
+
 // src/teamcity/auth.ts
 var import_node_string_decoder = require("node:string_decoder");
 var import_crypto = require("crypto");
@@ -38850,20 +39001,17 @@ var TeamCityAPI = class _TeamCityAPI {
         nextStartLine: lines.length === lineCount ? startLine + lines.length : void 0
       };
     } catch {
-      const full = await this.getBuildLog(buildId);
-      const allLines = full.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
-      if (allLines.length > 0 && allLines[allLines.length - 1] === "") allLines.pop();
-      const start = Math.max(0, Math.min(startLine, allLines.length));
-      const end = Math.min(allLines.length, start + lineCount);
-      const slice = allLines.slice(start, end);
-      return {
-        lines: slice,
-        startLine: start,
-        nextStartLine: end < allLines.length ? end : void 0,
-        totalLines: allLines.length
-      };
+      return readLineRange(await this.streamBuildLog(buildId), startLine, lineCount);
     }
   }
+  async getBuildLogTail(buildId, lineCount) {
+    return readLastLines(await this.streamBuildLog(buildId), lineCount);
+  }
+  async streamBuildLog(buildId) {
+    const response = await this.downloadBuildLog(buildId, { responseType: "stream" });
+    const data = response.data;
+    return isReadableStream(data) ? data : import_stream4.Readable.from([String(data ?? "")]);
+  }
   async listBuildTypes(projectId) {
     const locator = projectId ? `affectedProject:(id:${projectId})` : void 0;
     const response = await this.buildTypes.getAllBuildTypes(locator);
@@ -39113,7 +39261,7 @@ var ensureUniquePath = async (candidate) => {
   const probe = async (attempt) => {
     const next = attempt === 0 ? candidate : `${stem}-${attempt}${ext}`;
     try {
-      const handle = await import_node_fs2.promises.open(next, "wx");
+      const handle = await import_node_fs3.promises.open(next, "wx");
       await handle.close();
       return next;
     } catch (error3) {
@@ -39130,7 +39278,7 @@ var resolveStreamOutputPath = async (artifact, options) => {
   const { explicitOutputPath } = options;
   if (typeof explicitOutputPath === "string" && explicitOutputPath.length > 0) {
     const target = explicitOutputPath;
-    await import_node_fs2.promises.mkdir((0, import_node_path.dirname)(target), { recursive: true });
+    await import_node_fs3.promises.mkdir((0, import_node_path.dirname)(target), { recursive: true });
     return target;
   }
   if (options.outputDir) {
@@ -39143,17 +39291,17 @@ var resolveStreamOutputPath = async (artifact, options) => {
     if (relativePath.startsWith("..") || (0, import_node_path.isAbsolute)(relativePath)) {
       throw new Error("Resolved artifact path escapes the configured output directory");
     }
-    await import_node_fs2.promises.mkdir((0, import_node_path.dirname)(candidate), { recursive: true });
+    await import_node_fs3.promises.mkdir((0, import_node_path.dirname)(candidate), { recursive: true });
     return ensureUniquePath(candidate);
   }
   const tempFilePath = (0, import_node_path.join)((0, import_node_os.tmpdir)(), buildRandomFileName(artifact.name));
-  await import_node_fs2.promises.mkdir((0, import_node_path.dirname)(tempFilePath), { recursive: true });
+  await import_node_fs3.promises.mkdir((0, import_node_path.dirname)(tempFilePath), { recursive: true });
   return tempFilePath;
 };
 var writeArtifactStreamToDisk = async (artifact, stream, options) => {
   const targetPath = await resolveStreamOutputPath(artifact, options);
-  await (0, import_promises.pipeline)(stream, (0, import_node_fs2.createWriteStream)(targetPath));
-  const stats = await import_node_fs2.promises.stat(targetPath);
+  await (0, import_promises.pipeline)(stream, (0, import_node_fs3.createWriteStream)(targetPath));
+  const stats = await import_node_fs3.promises.stat(targetPath);
   return { outputPath: targetPath, bytesWritten: stats.size };
 };
 var buildArtifactPayload = async (artifact, encoding, options) => {
@@ -40241,13 +40389,17 @@ var DEV_TOOLS = [
         tail: { type: "boolean", description: "Tail mode: return last N lines" },
         encoding: {
           type: "string",
-          description: "Response encoding: 'text' (default) or 'stream'",
+          description: "Response encoding: 'text' (default) or 'stream'. 'stream' writes the whole log, or the requested line range, to outputPath; logs can be several GB",
           enum: ["text", "stream"],
           default: "text"
         },
         outputPath: {
           type: "string",
           description: "Optional absolute path to write streamed logs; defaults to a temp file when streaming"
+        },
+        minFreeDiskMb: {
+          type: "number",
+          description: "Streaming only: disk space in MiB that must stay free on the target disk, otherwise the download aborts (default 1024, 0 disables the reserve)"
         }
       },
       required: []
@@ -40263,7 +40415,8 @@ var DEV_TOOLS = [
         lineCount: import_zod4.z.coerce.number().int().min(1).max(5e3).optional(),
         tail: import_zod4.z.boolean().optional(),
         encoding: import_zod4.z.enum(["text", "stream"]).default("text"),
-        outputPath: import_zod4.z.string().min(1).optional()
+        outputPath: import_zod4.z.string().min(1).optional(),
+        minFreeDiskMb: import_zod4.z.coerce.number().min(0).optional()
       }).superRefine((value, ctx) => {
         if (!value.buildId && typeof value.buildNumber === "undefined") {
           ctx.addIssue({
@@ -40358,12 +40511,11 @@ var DEV_TOOLS = [
           const attemptBuffered = async () => {
             if (typed.tail) {
               const count = typed.lineCount ?? typed.pageSize ?? 500;
-              const full = await adapter.getBuildLog(effectiveBuildId);
-              const allLines = full.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
-              if (allLines.length > 0 && allLines[allLines.length - 1] === "") allLines.pop();
-              const total = allLines.length;
-              const start = Math.max(0, total - count);
-              const lines = allLines.slice(start);
+              const { lines, totalLines: total } = await adapter.getBuildLogTail(
+                effectiveBuildId,
+                count
+              );
+              const start = total - lines.length;
               return json({
                 lines,
                 meta: {
@@ -40406,11 +40558,9 @@ var DEV_TOOLS = [
           const attemptStream = async () => {
             const effectivePageSize = typed.lineCount ?? typed.pageSize ?? 500;
             const startLine = typeof typed.startLine === "number" ? typed.startLine : ((typed.page ?? 1) - 1) * effectivePageSize;
+            const ranged = typed.startLine !== void 0 || typed.page !== void 0 || typed.lineCount !== void 0 || typed.pageSize !== void 0;
             const response = await adapter.downloadBuildLogContent(effectiveBuildId, {
-              params: {
-                start: startLine,
-                count: effectivePageSize
-              },
+              params: ranged ? { start: startLine, count: effectivePageSize } : void 0,
               responseType: "stream"
             });
             const stream = response.data;
@@ -40420,9 +40570,34 @@ var DEV_TOOLS = [
             const safeBuildId = effectiveBuildId.replace(/[^a-zA-Z0-9._-]/g, "_") || "build";
             const defaultFileName = `build-log-${safeBuildId}-${startLine}-${(0, import_node_crypto.randomUUID)()}.log`;
             const targetPath = typed.outputPath ?? (0, import_node_path.join)((0, import_node_os.tmpdir)(), defaultFileName);
-            await import_node_fs2.promises.mkdir((0, import_node_path.dirname)(targetPath), { recursive: true });
-            await (0, import_promises.pipeline)(stream, (0, import_node_fs2.createWriteStream)(targetPath));
-            const stats = await import_node_fs2.promises.stat(targetPath);
+            const targetDir = (0, import_node_path.dirname)(targetPath);
+            const contentLength = Number(response.headers?.["content-length"]);
+            const minFreeBytes = typed.minFreeDiskMb === void 0 ? DEFAULT_MIN_FREE_DISK_BYTES : typed.minFreeDiskMb * 1024 ** 2;
+            let freeBytes;
+            try {
+              await import_node_fs3.promises.mkdir(targetDir, { recursive: true });
+              freeBytes = await assertDiskSpace(
+                targetDir,
+                !ranged && Number.isFinite(contentLength) ? contentLength : 0,
+                minFreeBytes
+              );
+            } catch (error3) {
+              stream.destroy();
+              throw error3;
+            }
+            try {
+              await (0, import_promises.pipeline)(
+                stream,
+                createDiskSpaceGuard(targetDir, freeBytes, minFreeBytes),
+                (0, import_node_fs3.createWriteStream)(targetPath)
+              );
+            } catch (error3) {
+              if (error3 instanceof InsufficientDiskSpaceError) {
+                await import_node_fs3.promises.rm(targetPath, { force: true });
+              }
+              throw error3;
+            }
+            const stats = await import_node_fs3.promises.stat(targetPath);
             const page = Math.floor(startLine / effectivePageSize) + 1;
             return json({
               encoding: "stream",
@@ -40432,8 +40607,8 @@ var DEV_TOOLS = [
                 buildId: effectiveBuildId,
                 buildNumber: typeof typed.buildNumber !== "undefined" ? String(typed.buildNumber) : void 0,
                 buildTypeId: typed.buildTypeId,
-                page,
-                pageSize: effectivePageSize,
+                page: ranged ? page : void 0,
+                pageSize: ranged ? effectivePageSize : void 0,
                 startLine
               }
             });
@@ -45117,7 +45292,7 @@ var FULL_MODE_TOOLS = [
       if (typedArgs.privateKeyContent && typedArgs.privateKeyPath) {
         throw new Error("Provide only one of privateKeyContent or privateKeyPath, not both");
       }
-      const keyContent = typedArgs.privateKeyPath ? await import_node_fs2.promises.readFile(typedArgs.privateKeyPath, "utf-8") : typedArgs.privateKeyContent;
+      const keyContent = typedArgs.privateKeyPath ? await import_node_fs3.promises.readFile(typedArgs.privateKeyPath, "utf-8") : typedArgs.privateKeyContent;
       const formData = new FormData();
       formData.append("privateKey", new Blob([keyContent]), "key");
       const api = TeamCityAPI.getInstance();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daghis/teamcity-mcp",
-  "version": "2.12.9",
+  "version": "2.12.11",
   "description": "Model Control Protocol server for TeamCity CI/CD integration with AI coding assistants",
   "mcpName": "io.github.Daghis/teamcity",
   "main": "dist/index.js",
@@ -105,7 +105,7 @@
     },
     "axios": "^1.20.0",
     "body-parser": "^2.2.1",
-    "follow-redirects": "^1.16.0",
+    "follow-redirects": "^1.16.1",
     "glob@>=10.2.0 <10.5.0": "^10.5.0",
     "hono": "^4.12.14",
     "lodash-es": "^4.18.0",

package/server.json

@@ -7,13 +7,13 @@
     "source": "github"
   },
   "websiteUrl": "https://github.com/Daghis/teamcity-mcp",
-  "version": "2.12.9",
+  "version": "2.12.11",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@daghis/teamcity-mcp",
-      "version": "2.12.9",
+      "version": "2.12.11",
       "runtimeHint": "npx",
       "runtimeArguments": [
         {