@daghis/teamcity-mcp 1.10.1 → 1.10.2

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "1.10.1"
+  ".": "1.10.2"
 }

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [1.10.2](https://github.com/Daghis/teamcity-mcp/compare/teamcity-mcp-v1.10.1...teamcity-mcp-v1.10.2) (2025-09-27)
+
+
+### Bug Fixes
+
+* **tools:** clone_build_config uses manager (215) ([b84d1f8](https://github.com/Daghis/teamcity-mcp/commit/b84d1f80a4233783a93dd1e3ede9a83a7cf57171))
+* **tools:** clone_build_config uses manager (215) ([c4cd959](https://github.com/Daghis/teamcity-mcp/commit/c4cd959a9f35052bf95386162316a9ace5599eb6))
+
 ## [1.10.1](https://github.com/Daghis/teamcity-mcp/compare/teamcity-mcp-v1.10.0...teamcity-mcp-v1.10.1) (2025-09-27)
 
 

package/dist/index.js

@@ -1516,6 +1516,384 @@ var ArtifactManager = class _ArtifactManager {
   }
 };
 
+// src/teamcity/types/api-responses.ts
+function isBuildTypeData(data) {
+  return typeof data === "object" && data !== null && ("id" in data || "name" in data || "projectId" in data);
+}
+function isVcsRootsResponse(data) {
+  return typeof data === "object" && data !== null && "vcs-root" in data;
+}
+
+// src/teamcity/build-configuration-clone-manager.ts
+var BuildConfigurationCloneManager = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Retrieve complete build configuration from TeamCity
+   */
+  async retrieveConfiguration(configId) {
+    try {
+      const response = await this.client.modules.buildTypes.getBuildType(
+        configId,
+        "$long,steps($long),triggers($long),features($long),artifact-dependencies($long),snapshot-dependencies($long),parameters($long),vcs-root-entries($long)"
+      );
+      if (response.data == null || !isBuildTypeData(response.data)) {
+        return null;
+      }
+      const config2 = response.data;
+      let vcsRootId;
+      const vcsRootEntries = config2["vcs-root-entries"];
+      if (vcsRootEntries?.["vcs-root-entry"] && vcsRootEntries["vcs-root-entry"].length > 0) {
+        const firstEntry = vcsRootEntries["vcs-root-entry"][0];
+        if (firstEntry?.["vcs-root"]?.id) {
+          vcsRootId = firstEntry["vcs-root"].id;
+        }
+      }
+      const parameters = {};
+      if (config2.parameters?.property) {
+        for (const param of config2.parameters.property) {
+          if (param.name && param.value) {
+            parameters[param.name] = param.value;
+          }
+        }
+      }
+      const cfgId = config2.id;
+      const cfgName = config2.name;
+      if (!cfgId || !cfgName) {
+        throw new Error("Source configuration missing id or name");
+      }
+      return {
+        id: cfgId,
+        name: cfgName,
+        projectId: config2.projectId ?? config2.project?.id ?? "",
+        description: config2.description,
+        vcsRootId,
+        parameters,
+        templateId: config2.templates?.buildType?.[0]?.id,
+        steps: config2.steps?.step,
+        triggers: config2.triggers?.trigger,
+        features: config2.features?.feature,
+        artifactDependencies: config2["artifact-dependencies"]?.["artifact-dependency"],
+        snapshotDependencies: config2["snapshot-dependencies"]?.["snapshot-dependency"],
+        buildNumberCounter: (() => {
+          const counterProp = config2.settings?.property?.find(
+            (p) => p.name === "buildNumberCounter"
+          );
+          return counterProp?.value ? parseInt(counterProp.value, 10) : void 0;
+        })(),
+        buildNumberFormat: config2.settings?.property?.find(
+          (p) => p.name === "buildNumberPattern"
+        )?.value
+      };
+    } catch (err) {
+      const axiosError = err;
+      if (axiosError.response?.status === 404) {
+        debug("Build configuration not found", { configId });
+        return null;
+      }
+      if (axiosError.response?.status === 403) {
+        throw new Error("Permission denied: No access to source configuration");
+      }
+      throw err;
+    }
+  }
+  /**
+   * Validate target project exists and user has permissions
+   */
+  async validateTargetProject(projectId) {
+    try {
+      const response = await this.client.modules.projects.getProject(projectId, "$short");
+      const id = response.data?.id;
+      const name = response.data?.name;
+      if (id && name) {
+        return { id, name };
+      }
+      return null;
+    } catch (err) {
+      const axiosError = err;
+      if (axiosError.response?.status === 404) {
+        debug("Target project not found", { projectId });
+        return null;
+      }
+      if (axiosError.response?.status === 403) {
+        debug("No permission to access target project", { projectId });
+        return null;
+      }
+      throw err;
+    }
+  }
+  /**
+   * Handle VCS root cloning or reuse
+   */
+  async handleVcsRoot(vcsRootId, handling, targetProjectId) {
+    if (handling === "reuse") {
+      return { id: vcsRootId, name: "Reused VCS Root" };
+    }
+    try {
+      const vcsRootsResponse = await this.client.modules.vcsRoots.getAllVcsRoots(
+        `id:${vcsRootId}`,
+        "$long,vcsRoot($long,properties($long))"
+      );
+      if (vcsRootsResponse.data == null || !isVcsRootsResponse(vcsRootsResponse.data)) {
+        throw new Error("Invalid VCS root response");
+      }
+      const vcsRoots = vcsRootsResponse.data["vcs-root"] ?? [];
+      if (vcsRoots.length === 0) {
+        throw new Error("VCS root not found");
+      }
+      const sourceVcsRoot = vcsRoots[0];
+      if (sourceVcsRoot == null) {
+        throw new Error("VCS root data is invalid");
+      }
+      const clonedVcsRootName = `${sourceVcsRoot.name}_Clone_${Date.now()}`;
+      const clonedVcsRoot = {
+        name: clonedVcsRootName,
+        vcsName: sourceVcsRoot.vcsName,
+        project: {
+          id: targetProjectId
+        },
+        properties: sourceVcsRoot.properties
+      };
+      const createResponse = await this.client.modules.vcsRoots.addVcsRoot(
+        void 0,
+        clonedVcsRoot
+      );
+      const newId = createResponse.data.id;
+      const newName = createResponse.data.name;
+      if (!newId || !newName) {
+        throw new Error("Failed to obtain cloned VCS root id/name");
+      }
+      return { id: newId, name: newName };
+    } catch (err) {
+      error("Failed to clone VCS root", err);
+      throw new Error(`Failed to clone VCS root: ${err.message}`);
+    }
+  }
+  /**
+   * Apply parameter overrides to configuration
+   */
+  async applyParameterOverrides(sourceParameters, overrides) {
+    const mergedParameters = { ...sourceParameters };
+    for (const [key, value] of Object.entries(overrides)) {
+      if (!this.isValidParameterName(key)) {
+        throw new Error(`Invalid parameter name: ${key}`);
+      }
+      mergedParameters[key] = value;
+    }
+    return mergedParameters;
+  }
+  /**
+   * Clone the build configuration
+   */
+  async cloneConfiguration(source, options) {
+    const configId = options.id ?? this.generateBuildConfigId(options.targetProjectId, options.name);
+    const configPayload = {
+      id: configId,
+      name: options.name,
+      project: {
+        id: options.targetProjectId
+      }
+    };
+    if (options.description) {
+      configPayload.description = options.description;
+    }
+    if (source.templateId) {
+      configPayload.templates = {
+        buildType: [{ id: source.templateId }]
+      };
+    }
+    if (options.vcsRootId) {
+      configPayload["vcs-root-entries"] = {
+        "vcs-root-entry": [
+          {
+            "vcs-root": { id: options.vcsRootId },
+            "checkout-rules": ""
+          }
+        ]
+      };
+    }
+    if (source.steps && source.steps.length > 0) {
+      configPayload.steps = {
+        step: this.cloneBuildSteps(source.steps)
+      };
+    }
+    if (source.triggers && source.triggers.length > 0) {
+      configPayload.triggers = {
+        trigger: this.cloneTriggers(source.triggers)
+      };
+    }
+    if (source.features && source.features.length > 0) {
+      configPayload.features = {
+        feature: source.features.map((f) => this.deepCloneConfiguration(f))
+      };
+    }
+    if (source.artifactDependencies && source.artifactDependencies.length > 0) {
+      configPayload["artifact-dependencies"] = {
+        "artifact-dependency": this.updateDependencyReferences(
+          source.artifactDependencies,
+          source.id,
+          configId
+        )
+      };
+    }
+    if (source.snapshotDependencies && source.snapshotDependencies.length > 0) {
+      configPayload["snapshot-dependencies"] = {
+        "snapshot-dependency": this.updateDependencyReferences(
+          source.snapshotDependencies,
+          source.id,
+          configId
+        )
+      };
+    }
+    if (options.parameters && Object.keys(options.parameters).length > 0) {
+      configPayload.parameters = {
+        property: Object.entries(options.parameters).map(([name, value]) => ({
+          name,
+          value
+        }))
+      };
+    }
+    if (options.copyBuildCounter && source.buildNumberCounter) {
+      if (configPayload.settings == null) {
+        configPayload.settings = { property: [] };
+      }
+      configPayload.settings.property?.push({
+        name: "buildNumberCounter",
+        value: source.buildNumberCounter.toString()
+      });
+    }
+    if (source.buildNumberFormat) {
+      if (configPayload.settings == null) {
+        configPayload.settings = { property: [] };
+      }
+      configPayload.settings.property?.push({
+        name: "buildNumberPattern",
+        value: source.buildNumberFormat
+      });
+    }
+    try {
+      const response = await this.client.modules.buildTypes.createBuildType(
+        void 0,
+        this.prepareBuildTypePayload(configPayload)
+      );
+      const teamcityUrl = getTeamCityUrl();
+      const id = response.data.id;
+      const name = response.data.name;
+      if (!id || !name) {
+        throw new Error("Clone response missing id or name");
+      }
+      const result = {
+        id,
+        name,
+        projectId: response.data.projectId ?? options.targetProjectId,
+        description: response.data.description,
+        vcsRootId: options.vcsRootId,
+        parameters: options.parameters,
+        url: `${teamcityUrl}/viewType.html?buildTypeId=${id}`
+      };
+      info("Build configuration cloned", {
+        id: result.id,
+        name: result.name,
+        sourceId: source.id
+      });
+      return result;
+    } catch (err) {
+      const error2 = err;
+      if (error2.response?.status === 409) {
+        throw new Error(`Build configuration already exists with ID: ${configId}`);
+      }
+      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 configuration: ${message}`);
+      }
+      error(
+        "Failed to clone build configuration",
+        error2 instanceof Error ? error2 : new Error(String(error2))
+      );
+      throw error2;
+    }
+  }
+  /**
+   * Normalize cloned payload into the generated BuildType shape expected by the API
+   */
+  prepareBuildTypePayload(payload) {
+    const clone = typeof structuredClone === "function" ? structuredClone(payload) : JSON.parse(JSON.stringify(payload));
+    if (typeof clone.id !== "string" || typeof clone.name !== "string") {
+      throw new Error("Invalid build configuration payload: missing id or name");
+    }
+    if (typeof clone.project?.id !== "string") {
+      throw new Error("Invalid build configuration payload: missing project id");
+    }
+    return clone;
+  }
+  /**
+   * Deep clone configuration object and remove server-generated fields
+   */
+  deepCloneConfiguration(config2) {
+    const cloned = JSON.parse(JSON.stringify(config2));
+    delete cloned.href;
+    delete cloned.webUrl;
+    delete cloned.locator;
+    delete cloned.uuid;
+    delete cloned.links;
+    delete cloned._links;
+    return cloned;
+  }
+  /**
+   * Clone build steps with new IDs
+   */
+  cloneBuildSteps(steps) {
+    return steps.map((step, index) => {
+      const clonedStep = this.deepCloneConfiguration(step);
+      clonedStep.id = `RUNNER_${index + 1}`;
+      return clonedStep;
+    });
+  }
+  /**
+   * Clone triggers with new IDs
+   */
+  cloneTriggers(triggers) {
+    return triggers.map((trigger, index) => {
+      const clonedTrigger = this.deepCloneConfiguration(trigger);
+      clonedTrigger.id = `TRIGGER_${index + 1}`;
+      return clonedTrigger;
+    });
+  }
+  /**
+   * Update internal references in dependencies
+   */
+  updateDependencyReferences(dependencies, oldId, newId) {
+    return dependencies.map((dep) => {
+      const clonedDep = this.deepCloneConfiguration(dep);
+      if (clonedDep.sourceBuildTypeId === oldId) {
+        clonedDep.sourceBuildTypeId = newId;
+      }
+      if (clonedDep.dependsOnBuildTypeId === oldId) {
+        clonedDep.dependsOnBuildTypeId = newId;
+      }
+      return clonedDep;
+    });
+  }
+  /**
+   * Generate a unique build configuration ID
+   */
+  generateBuildConfigId(projectId, name) {
+    const cleanName = name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+    return `${projectId}_${cleanName}`;
+  }
+  /**
+   * Validate parameter name according to TeamCity rules
+   */
+  isValidParameterName(name) {
+    return /^[a-zA-Z0-9._-]+$/.test(name);
+  }
+};
+
 // src/teamcity/build-configuration-update-manager.ts
 var ARTIFACT_RULES_SETTINGS_FIELD = "settings/artifactRules";
 var ARTIFACT_RULES_LEGACY_FIELD = "artifactRules";
@@ -40712,22 +41090,88 @@ var FULL_MODE_TOOLS = [
         sourceBuildTypeId: { type: "string", description: "Source build type ID" },
         name: { type: "string", description: "New build configuration name" },
         id: { type: "string", description: "New build configuration ID" },
-        projectId: { type: "string", description: "Target project ID" }
+        projectId: { type: "string", description: "Target project ID" },
+        description: { type: "string", description: "Description for the cloned configuration" },
+        parameters: {
+          type: "object",
+          description: "Optional parameter overrides to apply to the clone",
+          additionalProperties: { type: "string" }
+        },
+        copyBuildCounter: {
+          type: "boolean",
+          description: "Copy the build number counter from the source configuration"
+        }
       },
       required: ["sourceBuildTypeId", "name", "id"]
     },
     handler: async (args) => {
-      const typedArgs = args;
-      const adapter = createAdapterFromTeamCityAPI(TeamCityAPI.getInstance());
-      const source = await adapter.getBuildType(typedArgs.sourceBuildTypeId);
-      const buildType = {
-        ...source,
-        name: typedArgs.name,
-        id: typedArgs.id,
-        project: { id: typedArgs.projectId ?? source.project?.id ?? "_Root" }
-      };
-      const response = await adapter.modules.buildTypes.createBuildType(void 0, buildType);
-      return json({ success: true, action: "clone_build_config", id: response.data.id });
+      const schema = import_zod4.z.object({
+        sourceBuildTypeId: import_zod4.z.string().min(1),
+        name: import_zod4.z.string().min(1),
+        id: import_zod4.z.string().min(1),
+        projectId: import_zod4.z.string().min(1).optional(),
+        description: import_zod4.z.string().optional(),
+        parameters: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.string()).optional(),
+        copyBuildCounter: import_zod4.z.boolean().optional()
+      }).superRefine((value, ctx) => {
+        if (value.id.trim() === "") {
+          ctx.addIssue({
+            code: import_zod4.z.ZodIssueCode.custom,
+            message: "id must be a non-empty string.",
+            path: ["id"]
+          });
+        }
+      });
+      return runTool(
+        "clone_build_config",
+        schema,
+        async (typedArgs) => {
+          const adapter = createAdapterFromTeamCityAPI(TeamCityAPI.getInstance());
+          const manager = new BuildConfigurationCloneManager(adapter);
+          const source = await manager.retrieveConfiguration(typedArgs.sourceBuildTypeId);
+          if (!source) {
+            return json({
+              success: false,
+              action: "clone_build_config",
+              error: `Source build configuration not found: ${typedArgs.sourceBuildTypeId}`
+            });
+          }
+          const targetProjectId = typedArgs.projectId ?? source.projectId;
+          if (!targetProjectId) {
+            return json({
+              success: false,
+              action: "clone_build_config",
+              error: "projectId is required when the source configuration does not specify a project."
+            });
+          }
+          try {
+            const cloned = await manager.cloneConfiguration(source, {
+              id: typedArgs.id,
+              name: typedArgs.name,
+              targetProjectId,
+              description: typedArgs.description ?? source.description,
+              parameters: typedArgs.parameters,
+              copyBuildCounter: typedArgs.copyBuildCounter
+            });
+            return json({
+              success: true,
+              action: "clone_build_config",
+              id: cloned.id,
+              name: cloned.name,
+              projectId: cloned.projectId,
+              url: cloned.url,
+              description: cloned.description
+            });
+          } catch (error2) {
+            return json({
+              success: false,
+              action: "clone_build_config",
+              error: error2 instanceof Error ? error2.message : "Failed to clone build configuration."
+            });
+          }
+        },
+        args
+      );
     },
     mode: "full"
   },