@daghis/teamcity-mcp 2.12.5 → 2.12.7

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [2.12.7](https://github.com/Daghis/teamcity-mcp/compare/teamcity-mcp-v2.12.6...teamcity-mcp-v2.12.7) (2026-10-03)
+
+
+### Bug Fixes
+
+* **build-log:** protect errors and bound stream snapshots ([#538](https://github.com/Daghis/teamcity-mcp/issues/538)) ([36a300c](https://github.com/Daghis/teamcity-mcp/commit/36a300c932fadeea6136effde9c93d82ad716780))
+
+## [2.12.6](https://github.com/Daghis/teamcity-mcp/compare/teamcity-mcp-v2.12.5...teamcity-mcp-v2.12.6) (2026-10-03)
+
+
+### Bug Fixes
+
+* **build-log:** repair streamed downloads and error logging ([#526](https://github.com/Daghis/teamcity-mcp/issues/526)) ([aca2eea](https://github.com/Daghis/teamcity-mcp/commit/aca2eea6b996668e75ed69318c8846cdfeee624d))
+
 ## [2.12.5](https://github.com/Daghis/teamcity-mcp/compare/teamcity-mcp-v2.12.4...teamcity-mcp-v2.12.5) (2026-10-03)
 
 

package/dist/index.js

@@ -42,6 +42,71 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/teamcity/utils/stream.ts
+async function* sliceLines(source, startLine, endLine) {
+  if (endLine !== void 0 && endLine <= startLine) {
+    return;
+  }
+  let line = 0;
+  for await (const raw of source) {
+    const chunk = toBuffer(raw);
+    let pos = 0;
+    while (pos < chunk.length) {
+      const newline = chunk.indexOf(10, pos);
+      const stop = newline === -1 ? chunk.length : newline + 1;
+      if (line >= startLine) {
+        yield chunk.subarray(pos, stop);
+      }
+      if (newline === -1) {
+        break;
+      }
+      line += 1;
+      pos = stop;
+      if (endLine !== void 0 && line >= endLine) {
+        return;
+      }
+    }
+  }
+}
+var import_stream, isReadableStream, destroyStream, discardStreamBody, toBuffer, sliceStreamLines;
+var init_stream = __esm({
+  "src/teamcity/utils/stream.ts"() {
+    "use strict";
+    import_stream = require("stream");
+    isReadableStream = (value) => typeof value === "object" && value !== null && typeof value.pipe === "function" && typeof value.on === "function";
+    destroyStream = (stream) => {
+      stream.on("error", () => void 0);
+      const destroyable = stream;
+      if (typeof destroyable.destroy === "function") {
+        destroyable.destroy();
+      } else {
+        stream.resume();
+      }
+    };
+    discardStreamBody = (value) => {
+      if (isReadableStream(value)) {
+        destroyStream(value);
+      }
+    };
+    toBuffer = (chunk) => {
+      if (Buffer.isBuffer(chunk)) {
+        return chunk;
+      }
+      return chunk instanceof Uint8Array ? Buffer.from(chunk) : Buffer.from(String(chunk));
+    };
+    sliceStreamLines = (source, startLine, lineCount) => {
+      const endLine = lineCount === void 0 ? void 0 : startLine + lineCount;
+      const slice = import_stream.Readable.from(sliceLines(source, startLine, endLine), { objectMode: false });
+      const destroySlice = slice._destroy.bind(slice);
+      slice._destroy = (error3, callback) => {
+        destroyStream(source);
+        destroySlice(error3, callback);
+      };
+      return slice;
+    };
+  }
+});
+
 // src/teamcity/errors.ts
 function isRetryableError(error3) {
   if (error3 instanceof TeamCityAPIError) {
@@ -63,9 +128,11 @@ function isRetryableError(error3) {
   }
   return false;
 }
-var TeamCityAPIError, TeamCityAuthorizationError, TeamCityNotFoundError, TeamCityRateLimitError, TeamCityServerError, TeamCityNetworkError, TeamCityRequestError, TeamCityTimeoutError, BuildNotFoundError, BuildAccessDeniedError;
+var import_node_util2, TeamCityAPIError, TeamCityAuthorizationError, TeamCityNotFoundError, TeamCityRateLimitError, TeamCityServerError, TeamCityNetworkError, TeamCityRequestError, TeamCityTimeoutError, BuildNotFoundError, BuildAccessDeniedError;
 var init_errors = __esm({
   "src/teamcity/errors.ts"() {
+    import_node_util2 = require("node:util");
+    init_stream();
     TeamCityAPIError = class _TeamCityAPIError extends Error {
       code;
       statusCode;
@@ -89,7 +156,7 @@ var init_errors = __esm({
        */
       static fromAxiosError(error3, requestId) {
         if (error3.response) {
-          const data = error3.response.data;
+          const data = isReadableStream(error3.response.data) ? void 0 : error3.response.data;
           return new _TeamCityAPIError(
             (typeof data?.["message"] === "string" ? data["message"] : null) ?? error3.message,
             (typeof data?.["code"] === "string" ? data["code"] : null) ?? `HTTP_${error3.response.status}`,
@@ -115,6 +182,9 @@ var init_errors = __esm({
           stack: this.stack
         };
       }
+      [import_node_util2.inspect.custom]() {
+        return this.toJSON();
+      }
     };
     TeamCityAuthorizationError = class extends TeamCityAPIError {
       constructor(message = "Authorization failed", requestId, originalError) {
@@ -956,7 +1026,21 @@ var import_types = require("@modelcontextprotocol/sdk/types.js");
 
 // src/utils/logger/index.ts
 var import_node_fs = require("node:fs");
+var import_node_util = require("node:util");
 var import_winston = __toESM(require("winston"));
+function safeStringify(value) {
+  try {
+    return (0, import_node_util.inspect)(value, {
+      depth: 4,
+      maxArrayLength: 50,
+      maxStringLength: 1e3,
+      breakLength: Infinity,
+      compact: true
+    });
+  } catch {
+    return "[Uninspectable value]";
+  }
+}
 var TeamCityLogger = class _TeamCityLogger {
   winston;
   config;
@@ -1052,7 +1136,8 @@ var TeamCityLogger = class _TeamCityLogger {
     if (projectId) contextParts.push(`project=${projectId}`);
     if (duration !== void 0) contextParts.push(`${duration}ms`);
     const contextString = contextParts.length > 0 ? ` [${contextParts.join(" ")}]` : "";
-    const metaString = Object.keys(otherMeta).length > 0 ? ` ${JSON.stringify(otherMeta)}` : "";
+    const metaEntries = Object.entries(otherMeta);
+    const metaString = metaEntries.length > 0 ? ` ${safeStringify(Object.fromEntries(metaEntries))}` : "";
     return `${baseLog}${contextString}${metaString}`;
   }
   /**
@@ -1225,7 +1310,7 @@ function debug2(message, meta) {
 // package.json
 var package_default = {
   name: "@daghis/teamcity-mcp",
-  version: "2.12.5",
+  version: "2.12.7",
   description: "Model Control Protocol server for TeamCity CI/CD integration with AI coding assistants",
   mcpName: "io.github.Daghis/teamcity",
   main: "dist/index.js",
@@ -4845,8 +4930,10 @@ axiosRetry.isRetryableError = isRetryableError2;
 var esm_default = axiosRetry;
 
 // src/teamcity/auth.ts
+var import_node_string_decoder = require("node:string_decoder");
 var import_crypto = require("crypto");
 init_errors();
+init_stream();
 var asTimingMetaContainer = (value) => {
   if (typeof value === "object" && value !== null) {
     return value;
@@ -4891,10 +4978,54 @@ function logResponse(response) {
   });
   return response;
 }
-function logAndTransformError(error3) {
+var STREAM_BODY_TIMEOUT_MS = 5e3;
+var streamToString = async (stream, maxBytes = 64 * 1024) => {
+  const chunks = [];
+  let total = 0;
+  let truncated = false;
+  for await (const chunk of stream) {
+    const buf = toBuffer(chunk);
+    const retained = buf.subarray(0, maxBytes - total);
+    chunks.push(retained);
+    total += retained.length;
+    if (total >= maxBytes) {
+      truncated = true;
+      break;
+    }
+  }
+  const decoder = new import_node_string_decoder.StringDecoder("utf8");
+  const text = decoder.write(Buffer.concat(chunks, total)) + (truncated ? "" : decoder.end());
+  if (Buffer.byteLength(text) <= maxBytes) {
+    return text;
+  }
+  return new import_node_string_decoder.StringDecoder("utf8").write(Buffer.from(text).subarray(0, maxBytes));
+};
+var snapshotStreamBody = async (stream, timeoutMs) => {
+  let timer;
+  const deadline = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => reject(new Error("Timed out reading streamed error body")), timeoutMs);
+  });
+  try {
+    return await Promise.race([streamToString(stream), deadline]);
+  } catch {
+    destroyStream(stream);
+    return void 0;
+  } finally {
+    clearTimeout(timer);
+  }
+};
+async function logAndTransformError(error3) {
   if (error3 instanceof TeamCityAPIError) {
     return Promise.reject(error3);
   }
+  const response = error3.response;
+  if (response && isReadableStream(response.data)) {
+    const requestTimeout = error3.config?.timeout ?? 0;
+    response.data = await snapshotStreamBody(
+      response.data,
+      requestTimeout > 0 ? Math.min(requestTimeout, STREAM_BODY_TIMEOUT_MS) : STREAM_BODY_TIMEOUT_MS
+    );
+  }
   const requestId = error3.config?.requestId;
   const tcError = TeamCityAPIError.fromAxiosError(error3, requestId);
   const meta = asTimingMetaContainer(error3.config)?._tcMeta;
@@ -4950,6 +5081,7 @@ function validateConfiguration(baseUrl, token) {
 
 // src/api-client.ts
 init_errors();
+init_stream();
 
 // src/teamcity-client/api/agent-api.ts
 var import_axios5 = __toESM(require("axios"));
@@ -38427,6 +38559,24 @@ var extractRetryAfterMilliseconds = (value) => {
   }
   return void 0;
 };
+var toOptionalLineNumber = (value) => {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : void 0;
+};
+var sliceLogData = (data, startLine, lineCount) => {
+  if (isReadableStream(data)) {
+    return sliceStreamLines(data, startLine, lineCount);
+  }
+  if (typeof data === "string") {
+    const lines = data.split("\n");
+    const end = lineCount === void 0 ? void 0 : startLine + lineCount;
+    return lines.slice(startLine, end).join("\n");
+  }
+  return data;
+};
 var TeamCityAPI = class _TeamCityAPI {
   static instance;
   static instanceConfig;
@@ -38491,6 +38641,7 @@ var TeamCityAPI = class _TeamCityAPI {
     this.http = this.axiosInstance;
     esm_default(this.axiosInstance, {
       retries: 3,
+      onRetry: (_retryCount, error3) => discardStreamBody(error3.response?.data),
       retryDelay: (retryCount, error3) => {
         const reqId = error3?.config?.requestId;
         const tcError = TeamCityAPIError.fromAxiosError(error3, reqId);
@@ -38748,27 +38899,51 @@ var TeamCityAPI = class _TeamCityAPI {
     );
   }
   async downloadBuildLog(buildId, options) {
+    const responseType = options?.responseType ?? "text";
+    const rawHeaders = options?.headers ?? void 0;
+    const headers = { Accept: "text/plain", ...rawHeaders ?? {} };
+    const transformResponse = options?.transformResponse ?? [(data) => data];
     const rawParams = options?.params ?? void 0;
-    const params = rawParams ? { ...rawParams } : {};
-    if (!Object.prototype.hasOwnProperty.call(params, "plain")) {
-      params["plain"] = true;
+    const { start, count, ...primaryParams } = rawParams ?? {};
+    const startLine = toOptionalLineNumber(start);
+    const lineCount = toOptionalLineNumber(count);
+    try {
+      const response = await this.axiosInstance.get(`/downloadBuildLog.html`, {
+        ...options,
+        params: { ...primaryParams, buildId },
+        headers,
+        responseType,
+        transformResponse
+      });
+      if (startLine === void 0 && lineCount === void 0) {
+        return response;
+      }
+      return { ...response, data: sliceLogData(response.data, startLine ?? 0, lineCount) };
+    } catch (primaryError) {
+      const status = primaryError instanceof TeamCityAPIError ? primaryError.statusCode : void 0;
+      if (status === void 0 || [401, 403, 429, 503].includes(status)) {
+        throw primaryError;
+      }
+      const params = rawParams ? { ...rawParams } : {};
+      if (!Object.prototype.hasOwnProperty.call(params, "plain")) {
+        params["plain"] = true;
+      }
+      try {
+        return await this.axiosInstance.get(`/app/rest/builds/${toBuildLocator(buildId)}/log`, {
+          ...options,
+          params,
+          headers,
+          responseType,
+          transformResponse
+        });
+      } catch (fallbackError) {
+        const fallbackStatus = fallbackError instanceof TeamCityAPIError ? fallbackError.statusCode : void 0;
+        if (fallbackStatus === 404 || fallbackStatus === 405) {
+          throw primaryError;
+        }
+        throw fallbackError;
+      }
     }
-    const rawHeaders = options?.headers ?? void 0;
-    const headers = rawHeaders ? { ...rawHeaders } : {};
-    const requestOptions = {
-      ...options,
-      params,
-      headers: {
-        Accept: "text/plain",
-        ...headers
-      },
-      responseType: options?.responseType ?? "text",
-      transformResponse: options?.transformResponse ?? [(data) => data]
-    };
-    return this.axiosInstance.get(
-      `/app/rest/builds/${toBuildLocator(buildId)}/log`,
-      requestOptions
-    );
   }
   async getBuildStatistics(buildId, fields) {
     return this.builds.getBuildStatisticValues(toBuildLocator(buildId), fields);
@@ -38857,7 +39032,7 @@ var extraHeadersEqual = (a, b) => {
 };
 
 // src/tools.ts
-var isReadableStream = (value) => typeof value === "object" && value !== null && typeof value.pipe === "function";
+var isReadableStream2 = (value) => typeof value === "object" && value !== null && typeof value.pipe === "function";
 var isAxios4042 = (error3) => (0, import_axios36.isAxiosError)(error3) && error3.response?.status === 404;
 var buildIdentifierSchema = import_zod4.z.object({
   buildId: import_zod4.z.string().min(1).optional(),
@@ -38982,7 +39157,7 @@ var writeArtifactStreamToDisk = async (artifact, stream, options) => {
 var buildArtifactPayload = async (artifact, encoding, options) => {
   if (encoding === "stream") {
     const contentStream = artifact.content;
-    if (!isReadableStream(contentStream)) {
+    if (!isReadableStream2(contentStream)) {
       throw new Error("Streaming download did not return a readable stream");
     }
     const { outputPath, bytesWritten } = await writeArtifactStreamToDisk(
@@ -39066,7 +39241,7 @@ var downloadArtifactByUrl = async (adapter, request, encoding, options) => {
   }
   if (encoding === "stream") {
     const stream = response.data;
-    if (!isReadableStream(stream)) {
+    if (!isReadableStream2(stream)) {
       throw new Error("Streaming download did not return a readable stream");
     }
     const artifact2 = {
@@ -40237,7 +40412,7 @@ var DEV_TOOLS = [
               responseType: "stream"
             });
             const stream = response.data;
-            if (!isReadableStream(stream)) {
+            if (!isReadableStream2(stream)) {
               throw new Error("Streaming log download did not return a readable stream");
             }
             const safeBuildId = effectiveBuildId.replace(/[^a-zA-Z0-9._-]/g, "_") || "build";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daghis/teamcity-mcp",
-  "version": "2.12.5",
+  "version": "2.12.7",
   "description": "Model Control Protocol server for TeamCity CI/CD integration with AI coding assistants",
   "mcpName": "io.github.Daghis/teamcity",
   "main": "dist/index.js",

package/server.json

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