@alexsarrell/jenkins-mcp-server 1.0.0 → 1.3.0

package/dist/tools/discovery.js

@@ -1,51 +1,71 @@
 import { z } from "zod";
-import { formatQueue, ok, error } from "../utils/formatters.js";
+import { formatQueue, formatQueueItem, ok, error, truncateText } from "../utils/formatters.js";
 export function registerDiscoveryTools(client, register) {
-    // 16. searchBuildLogs
-    register("searchBuildLogs", "Search build logs for a text pattern across recent builds. Like grep for Jenkins logs. Searches the last N builds (default: 5) and returns matching lines with context.", z.object({
+    // 16. searchBuildLogs (v2)
+    register("searchBuildLogs", "Search build logs for a pattern across recent builds. Supports regex, context lines, result filter, and progressive read for large logs. Streams the log and stops early once maxMatchesPerBuild is hit per build.", z.object({
         jobPath: z.string().describe("Full job path"),
-        pattern: z.string().describe("Text pattern to search for (case-insensitive substring match)"),
-        buildNumber: z.number().optional().describe("Search a specific build number only"),
-        lastN: z.number().optional().default(5).describe("Number of recent builds to search (default: 5, max: 20)"),
+        pattern: z.string().describe("Pattern to search for"),
+        buildNumber: z.number().optional().describe("Search a specific build only. Overrides lastN/onlyResults."),
+        lastN: z.number().optional().default(5).describe("Number of recent builds to search (max 20)"),
+        regex: z.boolean().optional().default(false).describe("Treat pattern as regex (default: case-insensitive substring)"),
+        before: z.number().optional().default(0).describe("Lines of context before each match"),
+        after: z.number().optional().default(0).describe("Lines of context after each match"),
+        maxMatchesPerBuild: z.number().optional().default(10).describe("Stop scanning a build after this many matches"),
+        onlyResults: z.array(z.enum(["SUCCESS", "FAILURE", "UNSTABLE", "ABORTED", "NOT_BUILT"])).optional()
+            .describe("Filter builds by result before searching. Default: search all."),
     }), async (args) => {
         const jobPath = args.jobPath;
         const pattern = args.pattern;
         const buildNumber = args.buildNumber;
         const lastN = Math.min(args.lastN || 5, 20);
+        const regex = args.regex ?? false;
+        const before = args.before ?? 0;
+        const after = args.after ?? 0;
+        const maxMatchesPerBuild = args.maxMatchesPerBuild ?? 10;
+        const onlyResults = args.onlyResults;
         try {
-            const patternLower = pattern.toLowerCase();
-            const results = [];
-            if (buildNumber) {
-                // Search specific build
-                const matches = await searchBuildLog(client, jobPath, buildNumber, patternLower);
-                if (matches.length > 0) {
-                    results.push(`Build #${buildNumber} (${matches.length} matches):`);
-                    results.push(...matches.map((m) => `  L${m.line}: ${m.text}`));
+            const matcher = (() => {
+                try {
+                    return regex ? new RegExp(pattern) : null;
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    throw new Error(`Invalid regex: ${msg}`);
                 }
+            })();
+            const isMatch = (line) => matcher ? matcher.test(line) : line.toLowerCase().includes(pattern.toLowerCase());
+            // Determine which builds to search.
+            let buildsToSearch;
+            if (buildNumber !== undefined) {
+                buildsToSearch = [buildNumber];
             }
             else {
-                // Get recent builds
                 const data = await client.get(jobPath, "/api/json", {
-                    tree: "builds[number]{0," + lastN + "}",
+                    tree: `builds[number,result]{0,${lastN}}`,
                 });
                 const jobData = data;
-                const builds = jobData.builds || [];
-                for (const build of builds) {
-                    const matches = await searchBuildLog(client, jobPath, build.number, patternLower);
-                    if (matches.length > 0) {
-                        results.push(`Build #${build.number} (${matches.length} matches):`);
-                        results.push(...matches.slice(0, 20).map((m) => `  L${m.line}: ${m.text}`));
-                        if (matches.length > 20) {
-                            results.push(`  ... and ${matches.length - 20} more matches`);
-                        }
-                        results.push("");
+                const builds = jobData.builds ?? [];
+                buildsToSearch = builds
+                    .filter((b) => !onlyResults || (b.result !== null && onlyResults.includes(b.result)))
+                    .map((b) => b.number);
+            }
+            const results = [];
+            for (const num of buildsToSearch) {
+                const matches = await searchOneBuild(client, jobPath, num, isMatch, before, after, maxMatchesPerBuild);
+                if (matches.length === 0)
+                    continue;
+                results.push(`Build #${num} (${matches.length}${matches.length >= maxMatchesPerBuild ? "+" : ""} matches):`);
+                for (const m of matches.slice(0, maxMatchesPerBuild)) {
+                    for (const c of m.context) {
+                        results.push(`  ${String(c.lineNumber).padStart(6)}: ${c.text}`);
                     }
+                    results.push("");
                 }
             }
             if (results.length === 0) {
-                return ok(`No matches found for "${pattern}" in ${buildNumber ? `build #${buildNumber}` : `last ${lastN} builds`}.`);
+                return ok(`No matches for "${pattern}" in ${buildNumber ? `build #${buildNumber}` : `last ${buildsToSearch.length} build(s)`}.`);
             }
-            return ok(`Search results for "${pattern}":\n\n${results.join("\n")}`);
+            return ok(truncateText(results.join("\n")));
         }
         catch (e) {
             return handleError(e);
@@ -64,7 +84,20 @@ export function registerDiscoveryTools(client, register) {
             return handleError(e);
         }
     });
-    // 18. enableDisableJob
+    // 18. getQueueItem
+    register("getQueueItem", "Get the state of a specific queue item by ID. Use the queue ID returned from triggerBuild ('Queue item: #N') to find which build was started — this bridges queue → build.", z.object({
+        queueId: z.number().int().describe("Queue item ID"),
+    }), async (args) => {
+        const queueId = args.queueId;
+        try {
+            const data = await client.getAbsolute(`/queue/item/${queueId}/api/json`);
+            return ok(formatQueueItem(data));
+        }
+        catch (e) {
+            return handleError(e);
+        }
+    });
+    // 19. enableDisableJob
     register("enableDisableJob", "Enable or disable a Jenkins job. Disabled jobs cannot be triggered.", z.object({
         jobPath: z.string().describe("Full job path"),
         enabled: z.boolean().describe("true to enable, false to disable"),
@@ -81,24 +114,101 @@ export function registerDiscoveryTools(client, register) {
         }
     });
 }
-async function searchBuildLog(client, jobPath, buildNumber, patternLower) {
+async function searchOneBuild(client, jobPath, buildNumber, isMatch, before, after, maxMatches) {
+    const matches = [];
+    let lineNumber = 0;
+    // Sliding context buffer of recent lines.
+    const tail = [];
+    // Pending matches awaiting `after` lines.
+    const pending = [];
+    let leftover = "";
     try {
-        const logText = await client.getRaw(jobPath, `/${buildNumber}/consoleText`);
-        const lines = logText.split("\n");
-        const matches = [];
-        for (let i = 0; i < lines.length; i++) {
-            if (lines[i].toLowerCase().includes(patternLower)) {
-                matches.push({
-                    line: i + 1,
-                    text: lines[i].substring(0, 200), // Truncate long lines
-                });
+        for await (const chunk of client.getProgressiveText(jobPath, buildNumber)) {
+            const data = leftover + chunk;
+            const lines = data.split("\n");
+            // The last fragment may be a partial line — keep it for the next chunk.
+            leftover = lines.pop() ?? "";
+            for (const line of lines) {
+                lineNumber++;
+                // Drain pending after-context.
+                for (let i = pending.length - 1; i >= 0; i--) {
+                    const p = pending[i];
+                    p.context.push({ lineNumber, text: line });
+                    p.collected++;
+                    if (p.collected >= after) {
+                        matches.push({ lineNumber: p.lineNumber, context: p.context });
+                        pending.splice(i, 1);
+                        if (matches.length >= maxMatches)
+                            return matches;
+                    }
+                }
+                if (isMatch(line)) {
+                    const ctx = [];
+                    // Take last `before` lines from tail.
+                    const startIdx = Math.max(0, tail.length - before);
+                    for (let j = startIdx; j < tail.length; j++) {
+                        ctx.push({ lineNumber: lineNumber - (tail.length - j), text: tail[j] });
+                    }
+                    ctx.push({ lineNumber, text: line });
+                    if (after === 0) {
+                        matches.push({ lineNumber, context: ctx });
+                    }
+                    else {
+                        pending.push({ lineNumber, collected: 0, context: ctx });
+                    }
+                    if (matches.length >= maxMatches)
+                        return matches;
+                }
+                tail.push(line);
+                if (tail.length > before)
+                    tail.shift();
             }
         }
-        return matches;
     }
     catch {
-        return [];
+        // Fallback to /consoleText (e.g., progressiveText not available).
+        const text = await client.getRaw(jobPath, `/${buildNumber}/consoleText`);
+        return fallbackSearch(text, isMatch, before, after, maxMatches);
+    }
+    // Process trailing fragment if log doesn't end with \n.
+    if (leftover.length > 0) {
+        lineNumber++;
+        for (const p of pending) {
+            p.context.push({ lineNumber, text: leftover });
+        }
+        if (isMatch(leftover)) {
+            const ctx = [];
+            const startIdx = Math.max(0, tail.length - before);
+            for (let j = startIdx; j < tail.length; j++) {
+                ctx.push({ lineNumber: lineNumber - (tail.length - j), text: tail[j] });
+            }
+            ctx.push({ lineNumber, text: leftover });
+            matches.push({ lineNumber, context: ctx });
+        }
+    }
+    // Final flush: emit pending matches with whatever after-context we got.
+    for (const p of pending) {
+        matches.push({ lineNumber: p.lineNumber, context: p.context });
+    }
+    return matches.slice(0, maxMatches);
+}
+function fallbackSearch(text, isMatch, before, after, maxMatches) {
+    const lines = text.split("\n");
+    const matches = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (!isMatch(lines[i]))
+            continue;
+        const ctx = [];
+        const start = Math.max(0, i - before);
+        const end = Math.min(lines.length - 1, i + after);
+        for (let j = start; j <= end; j++) {
+            ctx.push({ lineNumber: j + 1, text: lines[j] });
+        }
+        matches.push({ lineNumber: i + 1, context: ctx });
+        if (matches.length >= maxMatches)
+            return matches;
     }
+    return matches;
 }
 function handleError(e) {
     if (e && typeof e === "object" && "errorCode" in e) {

package/dist/tools/jobs.d.ts

@@ -1,4 +1,4 @@
 import { z } from "zod";
 import type { JenkinsClient } from "../jenkins-client.js";
 import type { ToolResult } from "../types.js";
-export declare function registerJobTools(client: JenkinsClient, register: (name: string, description: string, schema: z.ZodType, handler: (args: Record<string, unknown>) => Promise<ToolResult>) => void): void;
+export declare function registerJobTools(client: JenkinsClient, register: (name: string, description: string, schema: z.ZodType, handler: (args: Record<string, unknown>) => Promise<ToolResult>) => void, allowUnsafe: boolean): void;

package/dist/tools/jobs.js

@@ -1,6 +1,41 @@
 import { z } from "zod";
 import { formatJobList, formatJobDetail, ok, error, truncateText } from "../utils/formatters.js";
-export function registerJobTools(client, register) {
+import { mapJenkinsParameter } from "../utils/parameter-mapper.js";
+import { parseJobConfig, buildJobXml } from "../utils/job-xml.js";
+import { diffJobSpecs } from "../utils/job-diff.js";
+import { parameterSpec } from "../schemas/parameter.js";
+const pipelineSpecSchema = z.object({
+    type: z.literal("pipeline"),
+    description: z.string().optional(),
+    disabled: z.boolean().optional(),
+    scm: z.object({
+        type: z.literal("git"),
+        url: z.string(),
+        branches: z.array(z.string()).optional(),
+        credentialsId: z.string().optional(),
+        jenkinsfilePath: z.string().optional(),
+    }),
+    triggers: z.object({ cron: z.string().optional() }).optional(),
+    parameters: z.array(parameterSpec).optional(),
+    buildRetention: z.object({ numToKeep: z.number().optional(), daysToKeep: z.number().optional() }).optional(),
+});
+const multibranchSpecSchema = z.object({
+    type: z.literal("multibranch"),
+    description: z.string().optional(),
+    source: z.object({
+        type: z.literal("git"),
+        url: z.string(),
+        credentialsId: z.string().optional(),
+    }),
+    jenkinsfilePath: z.string().optional(),
+    orphanedItemStrategy: z.object({ numToKeep: z.number().optional(), daysToKeep: z.number().optional() }).optional(),
+});
+const folderSpecSchema = z.object({
+    type: z.literal("folder"),
+    description: z.string().optional(),
+});
+const jobSpecSchema = z.discriminatedUnion("type", [pipelineSpecSchema, multibranchSpecSchema, folderSpecSchema]);
+export function registerJobTools(client, register, allowUnsafe) {
     // 1. getJobs
     register("getJobs", "List Jenkins jobs at root level or in a specific folder. Returns job names, status, and last build info. For multibranch pipelines, lists branches as sub-jobs.", z.object({
         folder: z.string().optional().describe("Folder path (e.g., 'my-folder' or 'folder/subfolder'). Omit for root level."),
@@ -52,21 +87,90 @@ export function registerJobTools(client, register) {
             return handleError(e);
         }
     });
-    // 4. updateJobConfig
-    register("updateJobConfig", "Update a Jenkins job's XML configuration. Send the complete config.xml content. Use getJobConfig first to read the current config, modify it, then submit.", z.object({
-        jobPath: z.string().describe("Full job path (e.g., 'my-folder/my-job')"),
-        configXml: z.string().describe("Complete XML configuration for the job"),
+    // 3b. getJobParameters
+    register("getJobParameters", "Get the structured parameter schema for a Jenkins job. Returns each parameter's type (string/choice/boolean/password/file/run/credentials/unknown), default, choices, and description as JSON. Use this instead of getJob when you need to know what to pass to triggerBuild.", z.object({
+        jobPath: z.string().describe("Full job path"),
     }), async (args) => {
         const jobPath = args.jobPath;
-        const configXml = args.configXml;
         try {
-            await client.post(jobPath, "/config.xml", configXml, "application/xml");
-            return ok(`Job config updated successfully: ${jobPath}`);
+            const tree = "property[parameterDefinitions[name,type,description,defaultParameterValue[value],choices,projectName,credentialType,_class]]";
+            const data = await client.get(jobPath, "/api/json", { tree });
+            const job = data;
+            const defs = (job.property ?? []).flatMap((p) => p.parameterDefinitions ?? []);
+            const parameters = defs.map(mapJenkinsParameter);
+            return ok(JSON.stringify({ parameters }, null, 2));
+        }
+        catch (e) {
+            return handleError(e);
+        }
+    });
+    // 3c. describeJob
+    register("describeJob", "Get a structured view of a job's config (SCM url/branch, Jenkinsfile path, parameters, retention, cron) without parsing raw XML. Reports unrecognised XML elements via 'unknownXmlElements'. Read-only and safe.", z.object({
+        jobPath: z.string().describe("Full job path"),
+    }), async (args) => {
+        const jobPath = args.jobPath;
+        try {
+            const xml = await client.getRaw(jobPath, "/config.xml");
+            const desc = parseJobConfig(xml);
+            return ok(JSON.stringify(desc, null, 2));
+        }
+        catch (e) {
+            return handleError(e);
+        }
+    });
+    // 3d. previewJobConfig
+    register("previewJobConfig", "Generate Jenkins job XML config from a structured spec. Optionally diff against an existing job's current config (read-only — does not modify Jenkins). Use the resulting XML with updateJobConfig (gated by JENKINS_ALLOW_UNSAFE_OPERATIONS) once it looks right.", z.object({
+        spec: jobSpecSchema,
+        diffAgainstJobPath: z.string().optional().describe("If set, fetch the current config of this job and emit a structured diff."),
+    }), async (args) => {
+        const spec = args.spec;
+        const diffPath = args.diffAgainstJobPath;
+        try {
+            const xml = buildJobXml(spec);
+            const out = [`=== Generated config.xml (${spec.type}) ===`, xml];
+            if (diffPath) {
+                const currentXml = await client.getRaw(diffPath, "/config.xml");
+                const before = parseJobConfig(currentXml);
+                const after = parseJobConfig(xml);
+                const changes = diffJobSpecs(before, after);
+                out.push(`\n=== Diff against ${diffPath} ===`);
+                if (changes.length === 0) {
+                    out.push("(no structural changes)");
+                }
+                else {
+                    for (const c of changes) {
+                        out.push(`@@ ${c.path} @@`);
+                        out.push(`- ${c.before}`);
+                        out.push(`+ ${c.after}`);
+                    }
+                }
+                if (before.unknownXmlElements.length > 0) {
+                    out.push(`\n(skipped: ${before.unknownXmlElements.join(", ")})`);
+                }
+            }
+            return ok(out.join("\n"));
         }
         catch (e) {
             return handleError(e);
         }
     });
+    // 4. updateJobConfig (unsafe — requires JENKINS_ALLOW_UNSAFE_OPERATIONS=true)
+    if (allowUnsafe) {
+        register("updateJobConfig", "Update a Jenkins job's XML configuration. Send the complete config.xml content. Use getJobConfig first to read the current config, modify it, then submit.", z.object({
+            jobPath: z.string().describe("Full job path (e.g., 'my-folder/my-job')"),
+            configXml: z.string().describe("Complete XML configuration for the job"),
+        }), async (args) => {
+            const jobPath = args.jobPath;
+            const configXml = args.configXml;
+            try {
+                await client.post(jobPath, "/config.xml", configXml, "application/xml");
+                return ok(`Job config updated successfully: ${jobPath}`);
+            }
+            catch (e) {
+                return handleError(e);
+            }
+        });
+    }
 }
 function handleError(e) {
     if (e && typeof e === "object" && "errorCode" in e) {

package/dist/tools/pipeline.d.ts

@@ -1,4 +1,4 @@
 import { z } from "zod";
 import type { JenkinsClient } from "../jenkins-client.js";
 import type { ToolResult } from "../types.js";
-export declare function registerPipelineTools(client: JenkinsClient, register: (name: string, description: string, schema: z.ZodType, handler: (args: Record<string, unknown>) => Promise<ToolResult>) => void): void;
+export declare function registerPipelineTools(client: JenkinsClient, register: (name: string, description: string, schema: z.ZodType, handler: (args: Record<string, unknown>) => Promise<ToolResult>) => void, allowUnsafe: boolean): void;

package/dist/tools/pipeline.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { formatStages, formatDuration, ok, error, truncateText } from "../utils/formatters.js";
-export function registerPipelineTools(client, register) {
+export function registerPipelineTools(client, register, allowUnsafe) {
     // 11. getPipelineStages
     register("getPipelineStages", "Get pipeline stages overview for a build - shows stage names, status, and duration. Works with Pipeline (Workflow) jobs. Useful for understanding which stage failed.", z.object({
         jobPath: z.string().describe("Full job path"),
@@ -116,43 +116,45 @@ export function registerPipelineTools(client, register) {
             return handleError(e, "Replay page may not be available. Ensure the build is a Pipeline job.");
         }
     });
-    // 14. replayBuild
-    register("replayBuild", "Replay a pipeline build with optional script modifications. If no script is provided, replays with the same script. Use getPipelineScript first to get the current script, modify it, then replay.", z.object({
-        jobPath: z.string().describe("Full job path"),
-        buildNumber: z.number().describe("Build number to replay"),
-        mainScript: z.string().optional().describe("Modified Jenkinsfile content. If omitted, replays with the original script."),
-    }), async (args) => {
-        const jobPath = args.jobPath;
-        const buildNumber = args.buildNumber;
-        let mainScript = args.mainScript;
-        try {
-            // If no script provided, fetch current one
-            if (!mainScript) {
-                const html = await client.getRaw(jobPath, `/${buildNumber}/replay`);
-                const match = html.match(/name="_.mainScript"[^>]*>([\s\S]*?)<\/textarea>/);
-                if (match) {
-                    mainScript = decodeHtmlEntities(match[1]);
+    // 14. replayBuild (unsafe — requires JENKINS_ALLOW_UNSAFE_OPERATIONS=true)
+    if (allowUnsafe) {
+        register("replayBuild", "Replay a pipeline build with optional script modifications. If no script is provided, replays with the same script. Use getPipelineScript first to get the current script, modify it, then replay.", z.object({
+            jobPath: z.string().describe("Full job path"),
+            buildNumber: z.number().describe("Build number to replay"),
+            mainScript: z.string().optional().describe("Modified Jenkinsfile content. If omitted, replays with the original script."),
+        }), async (args) => {
+            const jobPath = args.jobPath;
+            const buildNumber = args.buildNumber;
+            let mainScript = args.mainScript;
+            try {
+                // If no script provided, fetch current one
+                if (!mainScript) {
+                    const html = await client.getRaw(jobPath, `/${buildNumber}/replay`);
+                    const match = html.match(/name="_.mainScript"[^>]*>([\s\S]*?)<\/textarea>/);
+                    if (match) {
+                        mainScript = decodeHtmlEntities(match[1]);
+                    }
+                    else {
+                        return error("Could not extract current pipeline script for replay.", "Try providing the script explicitly via the mainScript parameter.");
+                    }
                 }
-                else {
-                    return error("Could not extract current pipeline script for replay.", "Try providing the script explicitly via the mainScript parameter.");
+                // Submit replay
+                const formData = new URLSearchParams();
+                formData.set("mainScript", mainScript);
+                formData.set("json", JSON.stringify({ mainScript }));
+                const result = await client.postForm(jobPath, `/${buildNumber}/replay/run`, formData);
+                // The response redirects to the new build page
+                const location = result.response.headers.get("location");
+                if (location) {
+                    return ok(`Replay triggered successfully.\nNew build: ${location}`);
                 }
+                return ok(`Replay triggered for ${jobPath} build #${buildNumber}.`);
             }
-            // Submit replay
-            const formData = new URLSearchParams();
-            formData.set("mainScript", mainScript);
-            formData.set("json", JSON.stringify({ mainScript }));
-            const result = await client.postForm(jobPath, `/${buildNumber}/replay/run`, formData);
-            // The response redirects to the new build page
-            const location = result.response.headers.get("location");
-            if (location) {
-                return ok(`Replay triggered successfully.\nNew build: ${location}`);
+            catch (e) {
+                return handleError(e, "Replay requires Pipeline job type and appropriate permissions.");
             }
-            return ok(`Replay triggered for ${jobPath} build #${buildNumber}.`);
-        }
-        catch (e) {
-            return handleError(e, "Replay requires Pipeline job type and appropriate permissions.");
-        }
-    });
+        });
+    }
     // 15. restartFromStage
     register("restartFromStage", "Restart a pipeline from a specific stage. Requires the Declarative Pipeline plugin with 'Restart from Stage' support. Only works with top-level stages in Declarative pipelines and completed builds.", z.object({
         jobPath: z.string().describe("Full job path"),

package/dist/types.d.ts

@@ -60,6 +60,11 @@ export interface JenkinsBuild {
             shortDescription: string;
             userName?: string;
         }>;
+        parameters?: Array<{
+            _class?: string;
+            name: string;
+            value?: string | boolean | number;
+        }>;
     }>;
     artifacts?: BuildArtifact[];
     changeSets?: Array<{
@@ -128,6 +133,21 @@ export interface QueueItem {
     stuck: boolean;
     blocked: boolean;
 }
+export interface QueueItemDetail {
+    id: number;
+    task: {
+        name: string;
+        url: string;
+    };
+    why: string | null;
+    cancelled?: boolean;
+    executable?: {
+        number: number;
+        url: string;
+    };
+    _class?: string;
+}
+export type QueueItemState = "WAITING" | "BLOCKED" | "BUILDABLE" | "LEFT_QUEUE" | "CANCELLED" | "UNKNOWN";
 export interface JenkinsError {
     statusCode: number;
     message: string;

package/dist/utils/build-payload.d.ts

@@ -0,0 +1,10 @@
+export interface JsonParameter {
+    name: string;
+    value: string | string[];
+}
+export interface TriggerPayload {
+    formData: URLSearchParams;
+    jsonParameters: JsonParameter[];
+}
+export type ParameterValue = string | string[];
+export declare function buildTriggerPayload(parameters: Record<string, ParameterValue>, splitOnComma: boolean): TriggerPayload;

package/dist/utils/build-payload.js

@@ -0,0 +1,19 @@
+export function buildTriggerPayload(parameters, splitOnComma) {
+    const formData = new URLSearchParams();
+    const jsonParameters = [];
+    for (const [name, raw] of Object.entries(parameters)) {
+        const values = Array.isArray(raw)
+            ? raw
+            : splitOnComma && raw.includes(",")
+                ? raw.split(",").map((v) => v.trim())
+                : [raw];
+        for (const v of values) {
+            formData.append(name, v);
+        }
+        jsonParameters.push({
+            name,
+            value: values.length === 1 ? values[0] : values,
+        });
+    }
+    return { formData, jsonParameters };
+}

package/dist/utils/formatters.d.ts

@@ -1,4 +1,4 @@
-import type { JenkinsJob, JenkinsBuild, PipelineStage, QueueItem, ToolResult } from "../types.js";
+import type { JenkinsJob, JenkinsBuild, PipelineStage, QueueItem, QueueItemDetail, ToolResult } from "../types.js";
 export declare function truncateText(text: string, maxBytes?: number): string;
 export declare function formatJobStatus(color: string): string;
 export declare function formatTimestamp(ts: number): string;
@@ -10,3 +10,4 @@ export declare function formatStages(stages: PipelineStage[]): string;
 export declare function formatQueue(items: QueueItem[]): string;
 export declare function ok(text: string): ToolResult;
 export declare function error(message: string, suggestion?: string): ToolResult;
+export declare function formatQueueItem(item: QueueItemDetail): string;

package/dist/utils/formatters.js

@@ -116,6 +116,17 @@ export function formatBuild(build) {
     if (causes && causes.length > 0) {
         lines.push(`Triggered by: ${causes.join(", ")}`);
     }
+    // Parameters
+    const parametersAction = build.actions?.find((a) => a.parameters && a.parameters.length > 0);
+    if (parametersAction?.parameters) {
+        lines.push(`\nParameters (${parametersAction.parameters.length}):`);
+        for (const p of parametersAction.parameters) {
+            // Loose substring match — covers PasswordParameterValue and most plugin variants.
+            const isPassword = (p._class || "").toLowerCase().includes("password");
+            const display = isPassword ? "[hidden]" : String(p.value ?? "");
+            lines.push(`  ${p.name} = ${display}`);
+        }
+    }
     // Artifacts
     if (build.artifacts && build.artifacts.length > 0) {
         lines.push(`\nArtifacts (${build.artifacts.length}):`);
@@ -164,3 +175,32 @@ export function error(message, suggestion) {
         text += `\nSuggestion: ${suggestion}`;
     return { content: [{ type: "text", text }], isError: true };
 }
+function classifyQueueItem(item) {
+    if (item.cancelled)
+        return "CANCELLED";
+    const cls = item._class || "";
+    if (cls.endsWith("$WaitingItem"))
+        return "WAITING";
+    if (cls.endsWith("$BlockedItem"))
+        return "BLOCKED";
+    if (cls.endsWith("$BuildableItem"))
+        return "BUILDABLE";
+    if (cls.endsWith("$LeftItem"))
+        return "LEFT_QUEUE";
+    if (cls.endsWith("$CancelledItem"))
+        return "CANCELLED";
+    return "UNKNOWN";
+}
+export function formatQueueItem(item) {
+    const state = classifyQueueItem(item);
+    const lines = [`Queue item #${item.id}: ${state}`];
+    lines.push(`Task: ${item.task.name}`);
+    if (state === "LEFT_QUEUE" && item.executable) {
+        lines.push(`Build started: ${item.task.name} #${item.executable.number}`);
+        lines.push(`URL: ${item.executable.url}`);
+    }
+    else if (item.why) {
+        lines.push(`Why: ${item.why}`);
+    }
+    return lines.join("\n");
+}

package/dist/utils/job-diff.d.ts

@@ -0,0 +1,7 @@
+import type { JobDescription } from "./job-xml.js";
+export interface FieldChange {
+    path: string;
+    before: string;
+    after: string;
+}
+export declare function diffJobSpecs(before: JobDescription, after: JobDescription): FieldChange[];

package/dist/utils/job-diff.js

@@ -0,0 +1,29 @@
+function flatten(obj, prefix) {
+    if (obj === null || obj === undefined)
+        return { [prefix]: "(unset)" };
+    if (typeof obj !== "object")
+        return { [prefix]: String(obj) };
+    if (Array.isArray(obj))
+        return { [prefix]: JSON.stringify(obj) };
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        const next = prefix ? `${prefix}.${k}` : k;
+        Object.assign(out, flatten(v, next));
+    }
+    return out;
+}
+export function diffJobSpecs(before, after) {
+    const a = flatten(before, "");
+    const b = flatten(after, "");
+    const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+    const changes = [];
+    for (const k of keys) {
+        if (k === "rawConfigSha" || k.startsWith("unknownXmlElements"))
+            continue;
+        const left = a[k] ?? "(unset)";
+        const right = b[k] ?? "(unset)";
+        if (left !== right)
+            changes.push({ path: k, before: left, after: right });
+    }
+    return changes.sort((x, y) => x.path.localeCompare(y.path));
+}