@daghis/teamcity-mcp 0.9.2 → 1.0.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [1.0.1](https://github.com/Daghis/teamcity-mcp/compare/v1.0.0...v1.0.1) (2025-09-12)
+
+
+### Bug Fixes
+
+* **tools:** update_build_config uses 'settings/artifactRules' path; add tests ([#66](https://github.com/Daghis/teamcity-mcp/issues/66)) ([8b8afc6](https://github.com/Daghis/teamcity-mcp/commit/8b8afc6f41038bcde21a50a8662f90fa4acb7e9a))
+
+## [1.0.0](https://github.com/Daghis/teamcity-mcp/compare/v0.9.2...v1.0.0) (2025-09-12)
+
+### Features
+- 1.0 release: stabilize API surface and defaults
+
+### Docs
+- Add Claude Code setup command and context usage estimates (dev vs full)
+
 ## [0.9.2](https://github.com/Daghis/teamcity-mcp/compare/v0.9.1...v0.9.2) (2025-09-12)
 
 ### Bug Fixes

package/README.md

@@ -81,13 +81,15 @@ npx -y @daghis/teamcity-mcp
 npx -y @daghis/teamcity-mcp
 ```
 
-Register with Claude Code’s MCP (user scope):
-
-```bash
-claude mcp add teamcity -s user \
-  -- env TEAMCITY_URL="https://teamcity.example.com" TEAMCITY_TOKEN="tc_<your_token>" MCP_MODE=dev \
-     npx -y @daghis/teamcity-mcp
-```
+## Claude Code
+
+- Add the MCP:
+  - `claude mcp add [-s user] teamcity -- npx -y @daghis/teamcity-mcp`
+- With env vars (if not using .env):
+  - `claude mcp add [-s user] teamcity -- env TEAMCITY_URL="https://teamcity.example.com" TEAMCITY_TOKEN="tc_<your_token>" MCP_MODE=dev npx -y @daghis/teamcity-mcp`
+- Context usage (Opus 4.1, estimates):
+  - Dev (default): ~14k tokens for MCP tools
+  - Full (`MCP_MODE=full`): ~26k tokens for MCP tools
 
 ## Configuration
 

package/dist/index.js

@@ -579,7 +579,7 @@ function loadConfig() {
     },
     mcp: {
       name: "teamcity-mcp",
-      version: "0.1.0",
+      version: "1.0.0",
       protocolVersion: "1.0.0",
       capabilities: {
         tools: true,
@@ -924,6 +924,388 @@ function debug(message, meta) {
 // src/tools.ts
 var import_zod4 = require("zod");
 
+// src/teamcity/build-configuration-update-manager.ts
+var BuildConfigurationUpdateManager = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Retrieve current build configuration
+   */
+  async retrieveConfiguration(configId) {
+    try {
+      const response = await this.client.buildTypes.getBuildType(
+        configId,
+        "$long,parameters($long),settings($long),agent-requirements($long)"
+      );
+      if (response.data == null) {
+        return null;
+      }
+      const config2 = response.data;
+      const parameters = {};
+      if (config2.parameters?.property != null) {
+        for (const param of config2.parameters.property) {
+          if (param.name != null && param.value != null) {
+            parameters[param.name] = param.value;
+          }
+        }
+      }
+      const buildNumberFormat = config2.settings?.property?.find(
+        (p) => p.name === "buildNumberPattern"
+      )?.value;
+      const artifactRules = config2.settings?.property?.find(
+        (p) => p.name === "artifactRules"
+      )?.value;
+      const cleanBuild = config2.settings?.property?.find((p) => p.name === "cleanBuild")?.value === "true";
+      const executionTimeout = config2.settings?.property?.find(
+        (p) => p.name === "executionTimeoutMin"
+      )?.value;
+      const checkoutDirectory = config2.settings?.property?.find(
+        (p) => p.name === "checkoutDirectory"
+      )?.value;
+      if (!config2.id || !config2.name) {
+        throw new Error("Invalid configuration data: missing id or name");
+      }
+      return {
+        id: config2.id,
+        name: config2.name,
+        description: config2.description,
+        projectId: config2.projectId ?? config2.project?.id ?? "",
+        buildNumberFormat,
+        artifactRules,
+        parameters,
+        agentRequirements: config2["agent-requirements"],
+        buildOptions: {
+          cleanBuild,
+          executionTimeout: executionTimeout != null ? parseInt(executionTimeout, 10) : void 0,
+          checkoutDirectory
+        },
+        settings: config2.settings
+      };
+    } catch (err) {
+      if (err != null && typeof err === "object" && "response" in err && err.response?.status === 404) {
+        debug("Build configuration not found", { configId });
+        return null;
+      }
+      if (err != null && typeof err === "object" && "response" in err && err.response?.status === 403) {
+        throw new Error("Permission denied: No access to build configuration");
+      }
+      throw err;
+    }
+  }
+  /**
+   * Validate updates before applying
+   */
+  async validateUpdates(currentConfig, updates) {
+    debug("Validating updates", {
+      configId: currentConfig.id,
+      updateFields: Object.keys(updates)
+    });
+    if (updates.parameters) {
+      for (const paramName of Object.keys(updates.parameters)) {
+        if (!this.isValidParameterName(paramName)) {
+          throw new Error(`Invalid parameter name: ${paramName}`);
+        }
+      }
+    }
+    if (updates.removeParameters) {
+      for (const paramName of updates.removeParameters) {
+        if (!currentConfig.parameters?.[paramName]) {
+          throw new Error(`Parameter does not exist: ${paramName}`);
+        }
+      }
+    }
+    if (updates.parameters && updates.removeParameters) {
+      const addOrUpdate = Object.keys(updates.parameters);
+      const toRemove = updates.removeParameters;
+      const conflicts = addOrUpdate.filter((param) => toRemove.includes(param));
+      if (conflicts.length > 0) {
+        throw new Error(
+          `Conflict: Cannot update and remove the same parameter: ${conflicts.join(", ")}`
+        );
+      }
+    }
+    if (updates.buildNumberFormat) {
+      if (!this.isValidBuildNumberFormat(updates.buildNumberFormat)) {
+        throw new Error(`Invalid build number format: ${updates.buildNumberFormat}`);
+      }
+    }
+    if (updates.artifactRules) {
+      if (!this.isValidArtifactRules(updates.artifactRules)) {
+        throw new Error(`Invalid artifact rules: ${updates.artifactRules}`);
+      }
+    }
+    if (updates.buildOptions?.executionTimeout !== void 0) {
+      if (updates.buildOptions.executionTimeout < 0 || updates.buildOptions.executionTimeout > 1440) {
+        throw new Error("Execution timeout must be between 0 and 1440 minutes");
+      }
+    }
+    return true;
+  }
+  /**
+   * Apply updates to configuration
+   */
+  async applyUpdates(currentConfig, updates) {
+    info("Applying updates to build configuration", {
+      id: currentConfig.id,
+      updateCount: Object.keys(updates).length
+    });
+    const configPayload = {
+      id: currentConfig.id,
+      name: updates.name ?? currentConfig.name,
+      description: updates.description ?? currentConfig.description,
+      project: {
+        id: currentConfig.projectId
+      }
+    };
+    const settings = [];
+    if (updates.buildNumberFormat !== void 0) {
+      settings.push({
+        name: "buildNumberPattern",
+        value: updates.buildNumberFormat
+      });
+    }
+    if (updates.artifactRules !== void 0) {
+      settings.push({
+        name: "artifactRules",
+        value: updates.artifactRules
+      });
+    }
+    if (updates.buildOptions) {
+      if (updates.buildOptions.cleanBuild !== void 0) {
+        settings.push({
+          name: "cleanBuild",
+          value: updates.buildOptions.cleanBuild.toString()
+        });
+      }
+      if (updates.buildOptions.executionTimeout !== void 0) {
+        settings.push({
+          name: "executionTimeoutMin",
+          value: updates.buildOptions.executionTimeout.toString()
+        });
+      }
+      if (updates.buildOptions.checkoutDirectory !== void 0) {
+        settings.push({
+          name: "checkoutDirectory",
+          value: updates.buildOptions.checkoutDirectory
+        });
+      }
+    }
+    if (settings.length > 0) {
+      configPayload.settings = { property: settings };
+    }
+    const finalParameters = { ...currentConfig.parameters };
+    if (updates.removeParameters) {
+      for (const paramName of updates.removeParameters) {
+        delete finalParameters[paramName];
+      }
+    }
+    if (updates.parameters) {
+      Object.assign(finalParameters, updates.parameters);
+    }
+    if ((updates.parameters ?? updates.removeParameters) != null) {
+      configPayload.parameters = {
+        property: Object.entries(finalParameters).map(([name, value]) => ({
+          name,
+          value
+        }))
+      };
+    }
+    if (updates.agentRequirements) {
+      debug("Agent requirements update requested", updates.agentRequirements);
+    }
+    try {
+      if (updates.name !== void 0 || updates.description !== void 0) {
+        if (updates.name) {
+          await this.client.buildTypes.setBuildTypeField(currentConfig.id, "name", updates.name);
+        }
+        if (updates.description !== void 0) {
+          await this.client.buildTypes.setBuildTypeField(
+            currentConfig.id,
+            "description",
+            updates.description ?? ""
+          );
+        }
+      }
+      if (settings.length > 0) {
+        for (const setting of settings) {
+          await this.client.buildTypes.setBuildTypeField(
+            currentConfig.id,
+            `settings/${setting.name}`,
+            setting.value
+          );
+        }
+      }
+      if (updates.removeParameters) {
+        for (const paramName of updates.removeParameters) {
+          try {
+            await this.client.buildTypes.deleteBuildParameterOfBuildType(
+              paramName,
+              currentConfig.id
+            );
+          } catch (err) {
+            debug(`Failed to remove parameter ${paramName}`, err);
+          }
+        }
+      }
+      if (updates.parameters) {
+        for (const [name, value] of Object.entries(updates.parameters)) {
+          await this.client.buildTypes.setBuildTypeField(
+            currentConfig.id,
+            `parameters/${name}`,
+            value
+          );
+        }
+      }
+      const updatedConfig = await this.retrieveConfiguration(currentConfig.id);
+      if (!updatedConfig) {
+        throw new Error("Failed to retrieve updated configuration");
+      }
+      info("Configuration updated successfully", {
+        id: updatedConfig.id,
+        name: updatedConfig.name
+      });
+      return updatedConfig;
+    } catch (err) {
+      const error2 = err;
+      if (error2.response?.status === 409) {
+        throw new Error("Configuration was modified by another user");
+      }
+      if (error2.response?.status === 403) {
+        throw new Error("Permission denied: You need project edit permissions");
+      }
+      if (error2.response?.status === 400) {
+        const message = error2.response?.data?.message ?? "Invalid configuration";
+        throw new Error(`Invalid update: ${message}`);
+      }
+      error("Failed to apply updates", error2);
+      throw new Error("Partial update failure");
+    }
+  }
+  /**
+   * Generate change log comparing before and after states
+   */
+  generateChangeLog(currentConfig, updates) {
+    const changeLog = {};
+    if (updates.name && updates.name !== currentConfig.name) {
+      changeLog["name"] = {
+        before: currentConfig.name,
+        after: updates.name
+      };
+    }
+    if (updates.description !== void 0 && updates.description !== currentConfig.description) {
+      changeLog["description"] = {
+        before: currentConfig.description ?? "",
+        after: updates.description
+      };
+    }
+    if (updates.buildNumberFormat !== void 0 && updates.buildNumberFormat !== currentConfig.buildNumberFormat) {
+      changeLog["buildNumberFormat"] = {
+        before: currentConfig.buildNumberFormat ?? "",
+        after: updates.buildNumberFormat
+      };
+    }
+    if (updates.artifactRules !== void 0 && updates.artifactRules !== currentConfig.artifactRules) {
+      changeLog["artifactRules"] = {
+        before: currentConfig.artifactRules ?? "",
+        after: updates.artifactRules
+      };
+    }
+    if ((updates.parameters ?? updates.removeParameters) != null) {
+      const paramChanges = {};
+      if (updates.parameters) {
+        const added = {};
+        const updated = {};
+        for (const [key, value] of Object.entries(updates.parameters)) {
+          if (!currentConfig.parameters?.[key]) {
+            added[key] = value;
+          } else if (currentConfig.parameters[key] !== value) {
+            updated[key] = {
+              before: currentConfig.parameters[key],
+              after: value
+            };
+          }
+        }
+        if (Object.keys(added).length > 0) {
+          paramChanges.added = added;
+        }
+        if (Object.keys(updated).length > 0) {
+          paramChanges.updated = updated;
+        }
+      }
+      if (updates.removeParameters && updates.removeParameters.length > 0) {
+        paramChanges.removed = updates.removeParameters;
+      }
+      if (Object.keys(paramChanges).length > 0) {
+        changeLog["parameters"] = paramChanges;
+      }
+    }
+    if (updates.buildOptions) {
+      const optionChanges = {};
+      if (updates.buildOptions.cleanBuild !== void 0 && updates.buildOptions.cleanBuild !== currentConfig.buildOptions?.cleanBuild) {
+        optionChanges["cleanBuild"] = {
+          before: currentConfig.buildOptions?.cleanBuild ?? false,
+          after: updates.buildOptions.cleanBuild
+        };
+      }
+      if (updates.buildOptions.executionTimeout !== void 0 && updates.buildOptions.executionTimeout !== currentConfig.buildOptions?.executionTimeout) {
+        optionChanges["executionTimeout"] = {
+          before: currentConfig.buildOptions?.executionTimeout ?? 0,
+          after: updates.buildOptions.executionTimeout
+        };
+      }
+      if (updates.buildOptions.checkoutDirectory !== void 0 && updates.buildOptions.checkoutDirectory !== currentConfig.buildOptions?.checkoutDirectory) {
+        optionChanges["checkoutDirectory"] = {
+          before: currentConfig.buildOptions?.checkoutDirectory ?? "",
+          after: updates.buildOptions.checkoutDirectory
+        };
+      }
+      if (Object.keys(optionChanges).length > 0) {
+        changeLog["buildOptions"] = optionChanges;
+      }
+    }
+    return changeLog;
+  }
+  /**
+   * Rollback changes in case of failure
+   */
+  async rollbackChanges(configId, originalConfig) {
+    try {
+      info("Rolling back configuration changes", { configId });
+      await this.applyUpdates(originalConfig, {
+        name: originalConfig.name,
+        description: originalConfig.description,
+        buildNumberFormat: originalConfig.buildNumberFormat,
+        artifactRules: originalConfig.artifactRules,
+        parameters: originalConfig.parameters
+      });
+      info("Rollback completed successfully", { configId });
+    } catch (err) {
+      error("Failed to rollback changes", err);
+      throw new Error("Rollback failed: Manual intervention may be required");
+    }
+  }
+  /**
+   * Validate parameter name according to TeamCity rules
+   */
+  isValidParameterName(name) {
+    return /^[a-zA-Z0-9._-]+$/.test(name);
+  }
+  /**
+   * Validate build number format
+   */
+  isValidBuildNumberFormat(format) {
+    return format.includes("%") && (format.includes("build.counter") || format.includes("build.vcs.number") || format.includes("build.number"));
+  }
+  /**
+   * Validate artifact rules
+   */
+  isValidArtifactRules(rules) {
+    return rules.length > 0 && !rules.includes("\\\\");
+  }
+};
+
 // src/teamcity/build-results-manager.ts
 var import_axios = __toESM(require("axios"));
 var BuildResultsManager = class _BuildResultsManager {
@@ -26223,15 +26605,57 @@ var FULL_MODE_TOOLS = [
     handler: async (args) => {
       const typedArgs = args;
       const api = TeamCityAPI.getInstance();
-      if (typedArgs.name != null && typedArgs.name !== "") {
-        await api.buildTypes.setBuildTypeField(typedArgs.buildTypeId, "name", typedArgs.name);
-      }
-      if (typedArgs.description !== void 0) {
-        await api.buildTypes.setBuildTypeField(
-          typedArgs.buildTypeId,
-          "description",
-          typedArgs.description
-        );
+      try {
+        const clientLike = { buildTypes: api.buildTypes };
+        const manager = new BuildConfigurationUpdateManager(clientLike);
+        const current = await manager.retrieveConfiguration(typedArgs.buildTypeId);
+        if (current) {
+          const updates = {};
+          if (typedArgs.name != null && typedArgs.name !== "") updates.name = typedArgs.name;
+          if (typedArgs.description !== void 0) updates.description = typedArgs.description;
+          if (typedArgs.artifactRules !== void 0)
+            updates.artifactRules = typedArgs.artifactRules;
+          if (Object.keys(updates).length > 0) {
+            await manager.validateUpdates(current, updates);
+            await manager.applyUpdates(current, updates);
+          }
+        } else {
+          if (typedArgs.name != null && typedArgs.name !== "") {
+            await api.buildTypes.setBuildTypeField(typedArgs.buildTypeId, "name", typedArgs.name);
+          }
+          if (typedArgs.description !== void 0) {
+            await api.buildTypes.setBuildTypeField(
+              typedArgs.buildTypeId,
+              "description",
+              typedArgs.description
+            );
+          }
+          if (typedArgs.artifactRules !== void 0) {
+            await api.buildTypes.setBuildTypeField(
+              typedArgs.buildTypeId,
+              "settings/artifactRules",
+              typedArgs.artifactRules
+            );
+          }
+        }
+      } catch {
+        if (typedArgs.name != null && typedArgs.name !== "") {
+          await api.buildTypes.setBuildTypeField(typedArgs.buildTypeId, "name", typedArgs.name);
+        }
+        if (typedArgs.description !== void 0) {
+          await api.buildTypes.setBuildTypeField(
+            typedArgs.buildTypeId,
+            "description",
+            typedArgs.description
+          );
+        }
+        if (typedArgs.artifactRules !== void 0) {
+          await api.buildTypes.setBuildTypeField(
+            typedArgs.buildTypeId,
+            "settings/artifactRules",
+            typedArgs.artifactRules
+          );
+        }
       }
       if (typedArgs.paused !== void 0) {
         await api.buildTypes.setBuildTypeField(
@@ -26240,13 +26664,6 @@ var FULL_MODE_TOOLS = [
           String(typedArgs.paused)
         );
       }
-      if (typedArgs.artifactRules !== void 0) {
-        await api.buildTypes.setBuildTypeField(
-          typedArgs.buildTypeId,
-          "artifactRules",
-          typedArgs.artifactRules
-        );
-      }
       return json({ success: true, action: "update_build_config", id: typedArgs.buildTypeId });
     },
     mode: "full"