@daghis/teamcity-mcp 1.9.3 → 1.9.4

package/.release-please-config.json

@@ -0,0 +1,19 @@
+{
+  "packages": {
+    ".": {
+      "release-type": "node",
+      "extra-files": [
+        {
+          "type": "json",
+          "path": "server.json",
+          "jsonpath": "$.version"
+        },
+        {
+          "type": "json",
+          "path": "server.json",
+          "jsonpath": "$.packages[0].version"
+        }
+      ]
+    }
+  }
+}

package/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "1.9.4"
+}

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [1.9.4](https://github.com/Daghis/teamcity-mcp/compare/v1.9.3...v1.9.4) (2025-09-25)
+
+### Bug Fixes
+
+* **tools:** merge build step defaults during update (199) ([#203](https://github.com/Daghis/teamcity-mcp/issues/203)) ([43a668f](https://github.com/Daghis/teamcity-mcp/commit/43a668f0bdc3b0f69c6a3bca0e2a47c49f1cd1a7))
+
 ## [1.9.3](https://github.com/Daghis/teamcity-mcp/compare/v1.9.2...v1.9.3) (2025-09-21)
 
 

package/dist/index.js

@@ -655,6 +655,7 @@ var import_server = require("@modelcontextprotocol/sdk/server/index.js");
 var import_types = require("@modelcontextprotocol/sdk/types.js");
 
 // src/utils/logger/index.ts
+var import_node_fs = require("node:fs");
 var import_winston = __toESM(require("winston"));
 var TeamCityLogger = class _TeamCityLogger {
   winston;
@@ -758,9 +759,8 @@ var TeamCityLogger = class _TeamCityLogger {
    */
   ensureLogDirectory(directory) {
     try {
-      const fs2 = require("fs");
-      if (fs2.existsSync(directory) === false) {
-        fs2.mkdirSync(directory, { recursive: true });
+      if ((0, import_node_fs.existsSync)(directory) === false) {
+        (0, import_node_fs.mkdirSync)(directory, { recursive: true });
       }
     } catch (error2) {
       this.winston?.warn?.("Failed to create log directory, using current directory", { error: error2 });
@@ -922,7 +922,7 @@ function debug(message, meta) {
 
 // src/tools.ts
 var import_node_crypto = require("node:crypto");
-var import_node_fs = require("node:fs");
+var import_node_fs2 = require("node:fs");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
 var import_promises = require("node:stream/promises");
@@ -2763,7 +2763,7 @@ function formatError(err, context) {
   }
   if (err instanceof import_zod2.z.ZodError) {
     error("Validation Error", err, {
-      errors: err.errors,
+      errors: err.issues,
       ...context
     });
     return {
@@ -2771,7 +2771,7 @@ function formatError(err, context) {
       error: {
         message: "Validation failed",
         code: "VALIDATION_ERROR",
-        data: err.errors
+        data: err.issues
       }
     };
   }
@@ -37237,7 +37237,7 @@ var buildRandomFileName = (artifactName) => {
 };
 var sanitizePathSegments = (artifactPath, fallbackName) => {
   const rawSegments = artifactPath?.split("/") ?? [];
-  const sanitizedSegments = rawSegments.map((segment) => segment.trim()).filter((segment) => segment && segment !== "." && segment !== "..").map((segment) => segment.replace(/[^a-zA-Z0-9._-]/g, "_"));
+  const sanitizedSegments = rawSegments.map((segment) => segment.trim()).filter((segment) => segment.length > 0 && segment !== "." && segment !== "..").map((segment) => segment.replace(/[^a-zA-Z0-9._-]/g, "_"));
   if (sanitizedSegments.length === 0) {
     const { sanitizedBase } = sanitizeFileName(fallbackName);
     sanitizedSegments.push(sanitizedBase);
@@ -37250,7 +37250,7 @@ var ensureUniquePath = async (candidate) => {
   const probe = async (attempt) => {
     const next = attempt === 0 ? candidate : `${stem}-${attempt}${ext}`;
     try {
-      const handle = await import_node_fs.promises.open(next, "wx");
+      const handle = await import_node_fs2.promises.open(next, "wx");
       await handle.close();
       return next;
     } catch (error2) {
@@ -37264,9 +37264,10 @@ var ensureUniquePath = async (candidate) => {
   return probe(0);
 };
 var resolveStreamOutputPath = async (artifact, options) => {
-  if (options.explicitOutputPath) {
-    const target = options.explicitOutputPath;
-    await import_node_fs.promises.mkdir((0, import_node_path.dirname)(target), { recursive: true });
+  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 });
     return target;
   }
   if (options.outputDir) {
@@ -37279,17 +37280,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_fs.promises.mkdir((0, import_node_path.dirname)(candidate), { recursive: true });
+    await import_node_fs2.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_fs.promises.mkdir((0, import_node_path.dirname)(tempFilePath), { recursive: true });
+  await import_node_fs2.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_fs.createWriteStream)(targetPath));
-  const stats = await import_node_fs.promises.stat(targetPath);
+  await (0, import_promises.pipeline)(stream, (0, import_node_fs2.createWriteStream)(targetPath));
+  const stats = await import_node_fs2.promises.stat(targetPath);
   return { outputPath: targetPath, bytesWritten: stats.size };
 };
 var buildArtifactPayload = async (artifact, encoding, options) => {
@@ -38028,9 +38029,9 @@ 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_fs.promises.mkdir((0, import_node_path.dirname)(targetPath), { recursive: true });
-            await (0, import_promises.pipeline)(stream, (0, import_node_fs.createWriteStream)(targetPath));
-            const stats = await import_node_fs.promises.stat(targetPath);
+            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 page = Math.floor(startLine / effectivePageSize) + 1;
             return json({
               encoding: "stream",
@@ -40492,7 +40493,7 @@ var FULL_MODE_TOOLS = [
         stepId: import_zod4.z.string().min(1).optional(),
         name: import_zod4.z.string().optional(),
         type: import_zod4.z.string().optional(),
-        properties: import_zod4.z.record(import_zod4.z.unknown()).optional()
+        properties: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional()
       }).superRefine((value, ctx) => {
         if (value.action === "update" || value.action === "delete") {
           if (!value.stepId || value.stepId.trim() === "") {
@@ -40539,24 +40540,56 @@ var FULL_MODE_TOOLS = [
               });
             }
             case "update": {
+              const existingStepResponse = await adapter.modules.buildTypes.getBuildStep(
+                typedArgs.buildTypeId,
+                typedArgs.stepId,
+                "id,name,type,disabled,properties(property(name,value))",
+                {
+                  headers: {
+                    Accept: "application/json"
+                  }
+                }
+              );
+              const existingStep = existingStepResponse.data;
+              const toRecord2 = (collection) => {
+                if (!collection || !Array.isArray(collection.property)) {
+                  return {};
+                }
+                const entries = collection.property.filter((item) => {
+                  return Boolean(item?.name);
+                }).map((item) => {
+                  return [item.name, item.value != null ? String(item.value) : ""];
+                });
+                return Object.fromEntries(entries);
+              };
+              const existingProperties = toRecord2(existingStep?.properties);
               const updatePayload = {};
-              if (typedArgs.name != null) {
-                updatePayload["name"] = typedArgs.name;
+              const mergedName = typedArgs.name ?? existingStep?.name;
+              if (mergedName != null) {
+                updatePayload["name"] = mergedName;
               }
-              if (typedArgs.type != null) {
-                updatePayload["type"] = typedArgs.type;
+              const mergedType = typedArgs.type ?? existingStep?.type;
+              if (mergedType != null) {
+                updatePayload["type"] = mergedType;
+              }
+              if (existingStep?.disabled != null) {
+                updatePayload["disabled"] = existingStep.disabled;
               }
               const rawProps = typedArgs.properties ?? {};
-              const stepProps = Object.fromEntries(
+              const providedProps = Object.fromEntries(
                 Object.entries(rawProps).map(([k, v]) => [k, String(v)])
               );
-              if (stepProps["script.content"]) {
-                stepProps["use.custom.script"] = stepProps["use.custom.script"] ?? "true";
-                stepProps["script.type"] = stepProps["script.type"] ?? "customScript";
+              const mergedProps = {
+                ...existingProperties,
+                ...providedProps
+              };
+              if (mergedProps["script.content"] && mergedType === "simpleRunner") {
+                mergedProps["use.custom.script"] = mergedProps["use.custom.script"] ?? "true";
+                mergedProps["script.type"] = mergedProps["script.type"] ?? "customScript";
               }
-              if (Object.keys(stepProps).length > 0) {
+              if (Object.keys(mergedProps).length > 0) {
                 updatePayload["properties"] = {
-                  property: Object.entries(stepProps).map(([name, value]) => ({ name, value }))
+                  property: Object.entries(mergedProps).map(([name, value]) => ({ name, value }))
                 };
               }
               if (Object.keys(updatePayload).length === 0) {
@@ -40710,7 +40743,9 @@ var FULL_MODE_TOOLS = [
             const queue = await adapter.modules.buildQueue.getAllQueuedBuilds();
             const builds = queue.data?.build ?? [];
             const ids = new Set(typed.buildTypeIds);
-            const toCancel = builds.filter((b) => b.buildTypeId && ids.has(b.buildTypeId));
+            const toCancel = builds.filter(
+              (build) => typeof build.buildTypeId === "string" && ids.has(build.buildTypeId)
+            );
             for (const b of toCancel) {
               if (b.id == null) continue;
               await adapter.modules.buildQueue.deleteQueuedBuild(String(b.id));