@sentry/junior-gocd 0.189.0 → 0.191.0

package/README.md

@@ -2,6 +2,8 @@
 
 `@sentry/junior-gocd` adds read-only GoCD tools to Junior. The package does not contain settings for a specific GoCD deployment.
 
+Full setup guide: https://junior.sentry.dev/extend/gocd-plugin/
+
 ## Install
 
 ```ts
@@ -61,13 +63,23 @@ gocdPlugin({
 
 ## Tools
 
+- `pipelines`: returns visible pipeline names, groups, environments, and recent run state
 - `pipelineHistory`: returns recent runs for one pipeline
+- `pipelineRun`: returns one pipeline run with stage and job results
+- `pipelineStatus`: returns whether one pipeline is paused, locked, and schedulable
 - `stage`: returns one stage run, its jobs, and failed job names
+- `jobHistory`: returns recent runs for one job
+
+Tool results include operational state only. They do not include pipeline configuration, environment variables, source material, commit messages, user identities, agent identifiers, pause reasons, or console output.
 
 The tools use the GoCD 25.2.0 API:
 
+- dashboard: `GET /go/api/dashboard` with `Accept: application/vnd.go.cd.v4+json`
 - pipeline history: `GET /go/api/pipelines/:name/history` with `Accept: application/vnd.go.cd.v1+json`
+- pipeline run: `GET /go/api/pipelines/:name/:counter` with `Accept: application/vnd.go.cd.v1+json`
+- pipeline status: `GET /go/api/pipelines/:name/status` with `Accept: application/vnd.go.cd.v1+json`
 - stage run: `GET /go/api/stages/:pipeline_name/:stage_name/instance/:pipeline_counter/:stage_counter` with `Accept: application/vnd.go.cd.v3+json`
-- pipeline history limits `page_size` to 10 through 100
+- job history: `GET /go/api/jobs/:pipeline_name/:stage_name/:job_name/history` with `Accept: application/vnd.go.cd.v1+json`
+- pipeline and job history limit `page_size` to 10 through 100
 
 Keep pipeline names and other deployment-specific settings in the app that registers this plugin.

package/dist/errors.d.ts

@@ -0,0 +1,5 @@
+/** Throw a model-repairable error for a missing named GoCD resource. */
+export declare function throwGocdReadError(message: string, status: number, options: {
+    missingResourceIsInput: boolean;
+}): never;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAEA,wEAAwE;AACxE,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,OAAO,EAAE;IAAE,sBAAsB,EAAE,OAAO,CAAA;CAAE,GAC3C,KAAK,CAKP"}

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAEL,KAAK,WAAW,EAEhB,KAAK,kBAAkB,EACxB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAuB,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAI1E,MAAM,MAAM,mBAAmB,GAAG,IAAI,CACpC,WAAW,EACX,gBAAgB,GAAG,iBAAiB,GAAG,kBAAkB,CAC1D,CAAC;AAEF,MAAM,WAAW,6BAA8B,SAAQ,iBAAiB;IACtE;;;OAGG;IACH,KAAK,CAAC,EAAE,mBAAmB,CAAC;CAC7B;AAUD,qCAAqC;AACrC,wBAAgB,UAAU,CACxB,OAAO,GAAE,6BAAkC,GAC1C,kBAAkB,CA8CpB;AAED,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,KAAK,iBAAiB,GACvB,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAEL,KAAK,WAAW,EAEhB,KAAK,kBAAkB,EACxB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAuB,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAQ1E,MAAM,MAAM,mBAAmB,GAAG,IAAI,CACpC,WAAW,EACX,gBAAgB,GAAG,iBAAiB,GAAG,kBAAkB,CAC1D,CAAC;AAEF,MAAM,WAAW,6BAA8B,SAAQ,iBAAiB;IACtE;;;OAGG;IACH,KAAK,CAAC,EAAE,mBAAmB,CAAC;CAC7B;AAUD,qCAAqC;AACrC,wBAAgB,UAAU,CACxB,OAAO,GAAE,6BAAkC,GAC1C,kBAAkB,CAuDpB;AAED,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,KAAK,iBAAiB,GACvB,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -40,23 +40,86 @@ function resolveGocdBaseUrl(options = {}) {
   return parseBaseUrl(configuredBaseUrl).origin;
 }
 
-// src/tools/pipeline-history.ts
+// src/tools/pipelines.ts
 import {
   definePluginTool,
   pluginToolOutputSchema
 } from "@sentry/junior-plugin-api";
 import { z } from "zod";
+
+// src/errors.ts
+import { PluginToolInputError } from "@sentry/junior-plugin-api";
+function throwGocdReadError(message, status, options) {
+  if (status === 404 && options.missingResourceIsInput) {
+    throw new PluginToolInputError(message);
+  }
+  throw new Error(message);
+}
+
+// src/tools/pipelines.ts
+var stageSchema = z.object({
+  name: z.string(),
+  counter: z.union([z.string(), z.number()]),
+  status: z.string(),
+  scheduled_at: z.string().nullable().optional()
+}).passthrough();
+var instanceSchema = z.object({
+  label: z.string(),
+  counter: z.number(),
+  scheduled_at: z.string().nullable().optional(),
+  _embedded: z.object({ stages: z.array(stageSchema).default([]) })
+}).passthrough();
+var pipelineSchema = z.object({
+  name: z.string(),
+  last_updated_timestamp: z.number().nullable().optional(),
+  locked: z.boolean(),
+  pause_info: z.object({ paused: z.boolean() }),
+  _embedded: z.object({ instances: z.array(instanceSchema).default([]) })
+}).passthrough();
+var namedPipelineListSchema = z.object({ name: z.string(), pipelines: z.array(z.string()).default([]) }).passthrough();
+var dashboardSchema = z.object({
+  _embedded: z.object({
+    pipelines: z.array(pipelineSchema).default([]),
+    environments: z.array(namedPipelineListSchema).default([]),
+    pipeline_groups: z.array(namedPipelineListSchema).default([])
+  })
+});
+var stageOutputSchema = z.object({
+  name: z.string(),
+  counter: z.string(),
+  status: z.string(),
+  scheduledAt: z.string().nullable()
+});
+var instanceOutputSchema = z.object({
+  label: z.string(),
+  counter: z.number(),
+  scheduledAt: z.string().nullable(),
+  stages: z.array(stageOutputSchema)
+});
 var inputSchema = z.object({
-  pipeline: z.string().trim().min(1).describe("Exact GoCD pipeline name."),
-  count: z.number().int().min(1).max(100).default(20)
+  query: z.string().trim().min(1).optional().describe("Optional case-insensitive pipeline name filter."),
+  count: z.number().int().min(1).max(100).default(50)
 }).strict();
 var outputSchema = pluginToolOutputSchema.extend({
-  target: z.literal("pipeline_history"),
+  target: z.literal("pipelines"),
   baseUrl: z.string(),
-  pipeline: z.string(),
-  runs: z.array(z.unknown())
+  pipelines: z.array(
+    z.object({
+      name: z.string(),
+      lastUpdatedAt: z.number().nullable(),
+      locked: z.boolean(),
+      paused: z.boolean(),
+      runs: z.array(instanceOutputSchema)
+    })
+  ),
+  environments: z.array(
+    namedPipelineListSchema.pick({ name: true, pipelines: true })
+  ),
+  pipelineGroups: z.array(
+    namedPipelineListSchema.pick({ name: true, pipelines: true })
+  )
 });
-function createGocdPipelineHistoryTool(ctx, options = {}) {
+function createGocdPipelinesTool(ctx, options = {}) {
   return definePluginTool({
     annotations: {
       destructiveHint: false,
@@ -64,9 +127,230 @@ function createGocdPipelineHistoryTool(ctx, options = {}) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    description: "Fetch recent runs for an exact GoCD pipeline. Use this to inspect deployment history and stage or job results.",
+    description: "Search visible GoCD pipelines. Returns groups, environments, and recent runs. Use this to find an exact pipeline name.",
     inputSchema,
     outputSchema,
+    async execute(input) {
+      const baseUrl = resolveGocdBaseUrl(options);
+      const response = await ctx.egress.fetch({
+        operation: "gocd.dashboard",
+        provider: "gocd",
+        request: new Request(resolveGocdApiUrl(baseUrl, "/go/api/dashboard"), {
+          headers: { Accept: "application/vnd.go.cd.v4+json" },
+          method: "GET"
+        })
+      });
+      if (!response.ok) {
+        throwGocdReadError(
+          `GoCD pipelines failed with HTTP ${response.status}`,
+          response.status,
+          { missingResourceIsInput: false }
+        );
+      }
+      const body = dashboardSchema.parse(await response.json())._embedded;
+      const query = input.query?.toLocaleLowerCase();
+      const pipelines = body.pipelines.filter(
+        (pipeline) => !query || pipeline.name.toLocaleLowerCase().includes(query)
+      ).slice(0, input.count);
+      const pipelineNames = new Set(pipelines.map((pipeline) => pipeline.name));
+      return {
+        target: "pipelines",
+        baseUrl,
+        pipelines: pipelines.map((pipeline) => ({
+          name: pipeline.name,
+          lastUpdatedAt: pipeline.last_updated_timestamp ?? null,
+          locked: pipeline.locked,
+          paused: pipeline.pause_info.paused,
+          runs: pipeline._embedded.instances.map((instance) => ({
+            label: instance.label,
+            counter: instance.counter,
+            scheduledAt: instance.scheduled_at ?? null,
+            stages: instance._embedded.stages.map((stage) => ({
+              name: stage.name,
+              counter: String(stage.counter),
+              status: stage.status,
+              scheduledAt: stage.scheduled_at ?? null
+            }))
+          }))
+        })),
+        environments: body.environments.map(({ name, pipelines: pipelines2 }) => ({
+          name,
+          pipelines: pipelines2.filter(
+            (pipeline) => pipelineNames.has(pipeline)
+          )
+        })).filter(({ pipelines: pipelines2 }) => pipelines2.length > 0),
+        pipelineGroups: body.pipeline_groups.map(({ name, pipelines: pipelines2 }) => ({
+          name,
+          pipelines: pipelines2.filter(
+            (pipeline) => pipelineNames.has(pipeline)
+          )
+        })).filter(({ pipelines: pipelines2 }) => pipelines2.length > 0)
+      };
+    }
+  });
+}
+
+// src/tools/job-history.ts
+import {
+  definePluginTool as definePluginTool2,
+  pluginToolOutputSchema as pluginToolOutputSchema2
+} from "@sentry/junior-plugin-api";
+import { z as z2 } from "zod";
+var inputSchema2 = z2.object({
+  pipeline: z2.string().trim().min(1).describe("Exact GoCD pipeline name."),
+  stage: z2.string().trim().min(1).describe("Exact stage name."),
+  job: z2.string().trim().min(1).describe("Exact job name."),
+  count: z2.number().int().min(1).max(100).default(20)
+}).strict();
+var jobSchema = z2.object({
+  name: z2.string(),
+  scheduled_date: z2.number().nullable().optional(),
+  pipeline_counter: z2.number(),
+  rerun: z2.boolean(),
+  result: z2.string(),
+  state: z2.string(),
+  stage_counter: z2.union([z2.string(), z2.number()])
+}).passthrough();
+var bodySchema = z2.object({ jobs: z2.array(jobSchema).default([]) }).passthrough();
+var outputSchema2 = pluginToolOutputSchema2.extend({
+  target: z2.literal("job_history"),
+  baseUrl: z2.string(),
+  pipeline: z2.string(),
+  stage: z2.string(),
+  job: z2.string(),
+  runs: z2.array(
+    z2.object({
+      pipelineCounter: z2.number(),
+      stageCounter: z2.string(),
+      scheduledAt: z2.number().nullable(),
+      rerun: z2.boolean(),
+      result: z2.string(),
+      state: z2.string()
+    })
+  )
+});
+function createGocdJobHistoryTool(ctx, options = {}) {
+  return definePluginTool2({
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+      readOnlyHint: true
+    },
+    description: "Fetch recent runs for an exact GoCD job. The result includes counters, timestamps, and results. It excludes agent identifiers and user identities.",
+    inputSchema: inputSchema2,
+    outputSchema: outputSchema2,
+    async execute(input) {
+      const baseUrl = resolveGocdBaseUrl(options);
+      const pageSize = Math.min(100, Math.max(10, input.count));
+      const response = await ctx.egress.fetch({
+        operation: "gocd.job.history",
+        provider: "gocd",
+        request: new Request(
+          resolveGocdApiUrl(
+            baseUrl,
+            `/go/api/jobs/${encodeURIComponent(input.pipeline)}/${encodeURIComponent(input.stage)}/${encodeURIComponent(input.job)}/history?page_size=${pageSize}`
+          ),
+          {
+            headers: { Accept: "application/vnd.go.cd.v1+json" },
+            method: "GET"
+          }
+        )
+      });
+      if (!response.ok) {
+        throwGocdReadError(
+          `GoCD job history failed with HTTP ${response.status}`,
+          response.status,
+          { missingResourceIsInput: true }
+        );
+      }
+      const body = bodySchema.parse(await response.json());
+      return {
+        target: "job_history",
+        baseUrl,
+        pipeline: input.pipeline,
+        stage: input.stage,
+        job: input.job,
+        runs: body.jobs.slice(0, input.count).map((run) => ({
+          pipelineCounter: run.pipeline_counter,
+          stageCounter: String(run.stage_counter),
+          scheduledAt: run.scheduled_date ?? null,
+          rerun: run.rerun,
+          result: run.result,
+          state: run.state
+        }))
+      };
+    }
+  });
+}
+
+// src/tools/pipeline-history.ts
+import {
+  definePluginTool as definePluginTool3,
+  pluginToolOutputSchema as pluginToolOutputSchema3
+} from "@sentry/junior-plugin-api";
+import { z as z3 } from "zod";
+var inputSchema3 = z3.object({
+  pipeline: z3.string().trim().min(1).describe("Exact GoCD pipeline name."),
+  count: z3.number().int().min(1).max(100).default(20)
+}).strict();
+var jobSchema2 = z3.object({
+  name: z3.string(),
+  result: z3.string().optional(),
+  state: z3.string().optional()
+}).passthrough();
+var stageSchema2 = z3.object({
+  name: z3.string(),
+  counter: z3.union([z3.string(), z3.number()]),
+  result: z3.string().optional(),
+  status: z3.string().optional(),
+  jobs: z3.array(jobSchema2).default([])
+}).passthrough();
+var runSchema = z3.object({
+  name: z3.string(),
+  counter: z3.number(),
+  label: z3.string().optional(),
+  scheduled_date: z3.number().nullable().optional(),
+  stages: z3.array(stageSchema2).default([])
+}).passthrough();
+var outputSchema3 = pluginToolOutputSchema3.extend({
+  target: z3.literal("pipeline_history"),
+  baseUrl: z3.string(),
+  pipeline: z3.string(),
+  runs: z3.array(
+    z3.object({
+      counter: z3.number(),
+      label: z3.string(),
+      scheduledAt: z3.number().nullable(),
+      stages: z3.array(
+        z3.object({
+          name: z3.string(),
+          counter: z3.string(),
+          result: z3.string(),
+          status: z3.string(),
+          jobs: z3.array(
+            z3.object({
+              name: z3.string(),
+              result: z3.string(),
+              state: z3.string()
+            })
+          )
+        })
+      )
+    })
+  )
+});
+function createGocdPipelineHistoryTool(ctx, options = {}) {
+  return definePluginTool3({
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+      readOnlyHint: true
+    },
+    description: "Fetch recent runs for an exact GoCD pipeline with stage and job results. The result excludes source material, commit messages, user identities, and environment variables.",
+    inputSchema: inputSchema3,
+    outputSchema: outputSchema3,
     async execute(input) {
       const baseUrl = resolveGocdBaseUrl(options);
       const pageSize = Math.min(100, Math.max(10, input.count));
@@ -91,54 +375,247 @@ function createGocdPipelineHistoryTool(ctx, options = {}) {
           `GoCD pipeline history failed with HTTP ${response.status}`
         );
       }
-      const body = z.object({ pipelines: z.array(z.unknown()) }).passthrough().parse(await response.json());
+      const body = z3.object({ pipelines: z3.array(runSchema) }).passthrough().parse(await response.json());
       return {
         baseUrl,
         pipeline: input.pipeline,
-        runs: body.pipelines.slice(0, input.count),
+        runs: body.pipelines.slice(0, input.count).map((run) => ({
+          counter: run.counter,
+          label: run.label ?? String(run.counter),
+          scheduledAt: run.scheduled_date ?? null,
+          stages: run.stages.map((stage) => ({
+            name: stage.name,
+            counter: String(stage.counter),
+            result: stage.result ?? "Unknown",
+            status: stage.status ?? "Unknown",
+            jobs: stage.jobs.map((job) => ({
+              name: job.name,
+              result: job.result ?? "Unknown",
+              state: job.state ?? "Unknown"
+            }))
+          }))
+        })),
         target: "pipeline_history"
       };
     }
   });
 }
 
+// src/tools/pipeline-run.ts
+import {
+  definePluginTool as definePluginTool4,
+  pluginToolOutputSchema as pluginToolOutputSchema4
+} from "@sentry/junior-plugin-api";
+import { z as z4 } from "zod";
+var inputSchema4 = z4.object({
+  pipeline: z4.string().trim().min(1).describe("Exact GoCD pipeline name."),
+  pipelineCounter: z4.number().int().min(1).describe("GoCD counter for the pipeline run.")
+}).strict();
+var jobSchema3 = z4.object({
+  name: z4.string(),
+  result: z4.string().optional(),
+  state: z4.string().optional()
+}).passthrough();
+var stageSchema3 = z4.object({
+  name: z4.string(),
+  counter: z4.union([z4.string(), z4.number()]),
+  result: z4.string().optional(),
+  status: z4.string().optional(),
+  scheduled: z4.boolean().optional(),
+  jobs: z4.array(jobSchema3).default([])
+}).passthrough();
+var bodySchema2 = z4.object({
+  name: z4.string(),
+  counter: z4.number(),
+  label: z4.string(),
+  scheduled_date: z4.number().nullable().optional(),
+  stages: z4.array(stageSchema3).default([])
+}).passthrough();
+var outputSchema4 = pluginToolOutputSchema4.extend({
+  target: z4.literal("pipeline_run"),
+  baseUrl: z4.string(),
+  pipeline: z4.string(),
+  pipelineCounter: z4.number(),
+  label: z4.string(),
+  scheduledAt: z4.number().nullable(),
+  stages: z4.array(
+    z4.object({
+      name: z4.string(),
+      counter: z4.string(),
+      result: z4.string(),
+      status: z4.string(),
+      scheduled: z4.boolean(),
+      jobs: z4.array(
+        z4.object({ name: z4.string(), result: z4.string(), state: z4.string() })
+      )
+    })
+  )
+});
+function createGocdPipelineRunTool(ctx, options = {}) {
+  return definePluginTool4({
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+      readOnlyHint: true
+    },
+    description: "Fetch one exact GoCD pipeline run with stage and job results. The result excludes source material, commit messages, user identities, and environment variables.",
+    inputSchema: inputSchema4,
+    outputSchema: outputSchema4,
+    async execute(input) {
+      const baseUrl = resolveGocdBaseUrl(options);
+      const response = await ctx.egress.fetch({
+        operation: "gocd.pipeline.run",
+        provider: "gocd",
+        request: new Request(
+          resolveGocdApiUrl(
+            baseUrl,
+            `/go/api/pipelines/${encodeURIComponent(input.pipeline)}/${input.pipelineCounter}`
+          ),
+          {
+            headers: { Accept: "application/vnd.go.cd.v1+json" },
+            method: "GET"
+          }
+        )
+      });
+      if (!response.ok) {
+        throwGocdReadError(
+          `GoCD pipeline run failed with HTTP ${response.status}`,
+          response.status,
+          { missingResourceIsInput: true }
+        );
+      }
+      const body = bodySchema2.parse(await response.json());
+      return {
+        target: "pipeline_run",
+        baseUrl,
+        pipeline: body.name,
+        pipelineCounter: body.counter,
+        label: body.label,
+        scheduledAt: body.scheduled_date ?? null,
+        stages: body.stages.map((stage) => ({
+          name: stage.name,
+          counter: String(stage.counter),
+          result: stage.result ?? "Unknown",
+          status: stage.status ?? "Unknown",
+          scheduled: stage.scheduled ?? false,
+          jobs: stage.jobs.map((job) => ({
+            name: job.name,
+            result: job.result ?? "Unknown",
+            state: job.state ?? "Unknown"
+          }))
+        }))
+      };
+    }
+  });
+}
+
+// src/tools/pipeline-status.ts
+import {
+  definePluginTool as definePluginTool5,
+  pluginToolOutputSchema as pluginToolOutputSchema5
+} from "@sentry/junior-plugin-api";
+import { z as z5 } from "zod";
+var inputSchema5 = z5.object({
+  pipeline: z5.string().trim().min(1).describe("Exact GoCD pipeline name.")
+}).strict();
+var bodySchema3 = z5.object({
+  paused: z5.boolean(),
+  locked: z5.boolean(),
+  schedulable: z5.boolean()
+}).passthrough();
+var outputSchema5 = pluginToolOutputSchema5.extend({
+  target: z5.literal("pipeline_status"),
+  baseUrl: z5.string(),
+  pipeline: z5.string(),
+  paused: z5.boolean(),
+  locked: z5.boolean(),
+  schedulable: z5.boolean()
+});
+function createGocdPipelineStatusTool(ctx, options = {}) {
+  return definePluginTool5({
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+      readOnlyHint: true
+    },
+    description: "Check whether an exact GoCD pipeline is paused, locked, and schedulable. The result excludes the pause reason and user identity.",
+    inputSchema: inputSchema5,
+    outputSchema: outputSchema5,
+    async execute(input) {
+      const baseUrl = resolveGocdBaseUrl(options);
+      const response = await ctx.egress.fetch({
+        operation: "gocd.pipeline.status",
+        provider: "gocd",
+        request: new Request(
+          resolveGocdApiUrl(
+            baseUrl,
+            `/go/api/pipelines/${encodeURIComponent(input.pipeline)}/status`
+          ),
+          {
+            headers: { Accept: "application/vnd.go.cd.v1+json" },
+            method: "GET"
+          }
+        )
+      });
+      if (!response.ok) {
+        throwGocdReadError(
+          `GoCD pipeline status failed with HTTP ${response.status}`,
+          response.status,
+          { missingResourceIsInput: true }
+        );
+      }
+      const body = bodySchema3.parse(await response.json());
+      return {
+        target: "pipeline_status",
+        baseUrl,
+        pipeline: input.pipeline,
+        paused: body.paused,
+        locked: body.locked,
+        schedulable: body.schedulable
+      };
+    }
+  });
+}
+
 // src/tools/stage.ts
 import {
-  definePluginTool as definePluginTool2,
-  pluginToolOutputSchema as pluginToolOutputSchema2
+  definePluginTool as definePluginTool6,
+  pluginToolOutputSchema as pluginToolOutputSchema6
 } from "@sentry/junior-plugin-api";
-import { z as z2 } from "zod";
-var inputSchema2 = z2.object({
-  pipeline: z2.string().trim().min(1).describe("Exact GoCD pipeline name."),
-  pipelineCounter: z2.number().int().min(1).describe("Pipeline run counter (integer)."),
-  stage: z2.string().trim().min(1).describe("Exact stage name."),
-  stageCounter: z2.number().int().min(1).describe("Stage run counter (integer).")
+import { z as z6 } from "zod";
+var inputSchema6 = z6.object({
+  pipeline: z6.string().trim().min(1).describe("Exact GoCD pipeline name."),
+  pipelineCounter: z6.number().int().min(1).describe("Pipeline run counter (integer)."),
+  stage: z6.string().trim().min(1).describe("Exact stage name."),
+  stageCounter: z6.number().int().min(1).describe("Stage run counter (integer).")
 }).strict();
-var jobSchema = z2.object({
-  name: z2.string(),
-  result: z2.string().optional(),
-  state: z2.string().optional()
+var jobSchema4 = z6.object({
+  name: z6.string(),
+  result: z6.string().optional(),
+  state: z6.string().optional()
 }).passthrough();
-var stageBodySchema = z2.object({
-  result: z2.string().optional(),
-  _embedded: z2.object({ jobs: z2.array(jobSchema).default([]) })
+var stageBodySchema = z6.object({
+  result: z6.string().optional(),
+  _embedded: z6.object({ jobs: z6.array(jobSchema4).default([]) })
 }).passthrough();
-var outputSchema2 = pluginToolOutputSchema2.extend({
-  target: z2.literal("stage"),
-  baseUrl: z2.string(),
-  link: z2.string(),
-  pipeline: z2.string(),
-  pipelineCounter: z2.number(),
-  stage: z2.string(),
-  stageCounter: z2.number(),
-  result: z2.string(),
-  jobs: z2.array(
-    z2.object({ name: z2.string(), result: z2.string(), state: z2.string() })
+var outputSchema6 = pluginToolOutputSchema6.extend({
+  target: z6.literal("stage"),
+  baseUrl: z6.string(),
+  link: z6.string(),
+  pipeline: z6.string(),
+  pipelineCounter: z6.number(),
+  stage: z6.string(),
+  stageCounter: z6.number(),
+  result: z6.string(),
+  jobs: z6.array(
+    z6.object({ name: z6.string(), result: z6.string(), state: z6.string() })
   ),
-  failedJobs: z2.array(z2.string())
+  failedJobs: z6.array(z6.string())
 });
 function createGocdStageTool(ctx, options = {}) {
-  return definePluginTool2({
+  return definePluginTool6({
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
@@ -146,8 +623,8 @@ function createGocdStageTool(ctx, options = {}) {
       readOnlyHint: true
     },
     description: "Fetch one exact GoCD stage run, its jobs, and failed job names. Identify the run with its pipeline name, pipeline counter, stage name, and stage counter.",
-    inputSchema: inputSchema2,
-    outputSchema: outputSchema2,
+    inputSchema: inputSchema6,
+    outputSchema: outputSchema6,
     async execute(input) {
       const baseUrl = resolveGocdBaseUrl(options);
       const path = `/go/api/stages/${encodeURIComponent(input.pipeline)}/${encodeURIComponent(input.stage)}/instance/${input.pipelineCounter}/${input.stageCounter}`;
@@ -201,13 +678,18 @@ function gocdPlugin(options = {}) {
     credentialHooks?.grantForEgress || credentialHooks?.issueCredential
   );
   const manifest = {
+    configKeys: ["pipeline"],
     description: "Read GoCD pipeline and stage results",
     displayName: "GoCD",
     envVars: {
       GOCD_ACCESS_TOKEN: {},
       GOCD_URL: {}
     },
-    name: "gocd"
+    name: "gocd",
+    target: {
+      configKey: "pipeline",
+      type: "pipeline"
+    }
   };
   if (hostname) {
     manifest.domains = [hostname];
@@ -220,7 +702,11 @@ function gocdPlugin(options = {}) {
   const hooks = {
     tools(ctx) {
       return {
+        pipelines: createGocdPipelinesTool(ctx, options),
+        jobHistory: createGocdJobHistoryTool(ctx, options),
         pipelineHistory: createGocdPipelineHistoryTool(ctx, options),
+        pipelineRun: createGocdPipelineRunTool(ctx, options),
+        pipelineStatus: createGocdPipelineStatusTool(ctx, options),
         stage: createGocdStageTool(ctx, options)
       };
     }

package/dist/tools/job-history.d.ts

@@ -0,0 +1,50 @@
+import { type ToolRegistrationHookContext } from "@sentry/junior-plugin-api";
+import { type GocdPluginOptions } from "../config.js";
+/** Return recent runs for one exact GoCD job. */
+export declare function createGocdJobHistoryTool(ctx: ToolRegistrationHookContext, options?: GocdPluginOptions): import("@sentry/junior-plugin-api").PluginToolDefinition<{
+    pipeline: string;
+    stage: string;
+    job: string;
+    count: number;
+}, {
+    [x: string]: unknown;
+    target: "job_history";
+    baseUrl: string;
+    pipeline: string;
+    stage: string;
+    job: string;
+    runs: {
+        pipelineCounter: number;
+        stageCounter: string;
+        scheduledAt: number | null;
+        rerun: boolean;
+        result: string;
+        state: string;
+    }[];
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    target: "job_history";
+    baseUrl: string;
+    pipeline: string;
+    stage: string;
+    job: string;
+    runs: {
+        pipelineCounter: number;
+        stageCounter: string;
+        scheduledAt: number | null;
+        rerun: boolean;
+        result: string;
+        state: string;
+    }[];
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+}>;
+//# sourceMappingURL=job-history.d.ts.map

package/dist/tools/job-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-history.d.ts","sourceRoot":"","sources":["../../src/tools/job-history.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,2BAA2B,EACjC,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,cAAc,CAAC;AAgDtB,iDAAiD;AACjD,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,2BAA2B,EAChC,OAAO,GAAE,iBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DhC"}

package/dist/tools/pipeline-history.d.ts

@@ -14,7 +14,22 @@ export declare function createGocdPipelineHistoryTool(ctx: ToolRegistrationHookC
     target: "pipeline_history";
     baseUrl: string;
     pipeline: string;
-    runs: unknown[];
+    runs: {
+        counter: number;
+        label: string;
+        scheduledAt: number | null;
+        stages: {
+            name: string;
+            counter: string;
+            result: string;
+            status: string;
+            jobs: {
+                name: string;
+                result: string;
+                state: string;
+            }[];
+        }[];
+    }[];
     truncated?: boolean | undefined;
     continuation?: {
         arguments: Record<string, unknown>;
@@ -25,7 +40,22 @@ export declare function createGocdPipelineHistoryTool(ctx: ToolRegistrationHookC
     target: "pipeline_history";
     baseUrl: string;
     pipeline: string;
-    runs: unknown[];
+    runs: {
+        counter: number;
+        label: string;
+        scheduledAt: number | null;
+        stages: {
+            name: string;
+            counter: string;
+            result: string;
+            status: string;
+            jobs: {
+                name: string;
+                result: string;
+                state: string;
+            }[];
+        }[];
+    }[];
     truncated?: boolean | undefined;
     continuation?: {
         arguments: Record<string, unknown>;

package/dist/tools/pipeline-history.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline-history.d.ts","sourceRoot":"","sources":["../../src/tools/pipeline-history.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,2BAA2B,EACjC,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,cAAc,CAAC;AAuBtB;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,2BAA2B,EAChC,OAAO,GAAE,iBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;GAkDhC"}
+{"version":3,"file":"pipeline-history.d.ts","sourceRoot":"","sources":["../../src/tools/pipeline-history.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,2BAA2B,EACjC,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,cAAc,CAAC;AAmEtB;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,2BAA2B,EAChC,OAAO,GAAE,iBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEhC"}

package/dist/tools/pipeline-run.d.ts

@@ -0,0 +1,58 @@
+import { type ToolRegistrationHookContext } from "@sentry/junior-plugin-api";
+import { type GocdPluginOptions } from "../config.js";
+/** Return the operational state for one exact GoCD pipeline run. */
+export declare function createGocdPipelineRunTool(ctx: ToolRegistrationHookContext, options?: GocdPluginOptions): import("@sentry/junior-plugin-api").PluginToolDefinition<{
+    pipeline: string;
+    pipelineCounter: number;
+}, {
+    [x: string]: unknown;
+    target: "pipeline_run";
+    baseUrl: string;
+    pipeline: string;
+    pipelineCounter: number;
+    label: string;
+    scheduledAt: number | null;
+    stages: {
+        name: string;
+        counter: string;
+        result: string;
+        status: string;
+        scheduled: boolean;
+        jobs: {
+            name: string;
+            result: string;
+            state: string;
+        }[];
+    }[];
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    target: "pipeline_run";
+    baseUrl: string;
+    pipeline: string;
+    pipelineCounter: number;
+    label: string;
+    scheduledAt: number | null;
+    stages: {
+        name: string;
+        counter: string;
+        result: string;
+        status: string;
+        scheduled: boolean;
+        jobs: {
+            name: string;
+            result: string;
+            state: string;
+        }[];
+    }[];
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+}>;
+//# sourceMappingURL=pipeline-run.d.ts.map

package/dist/tools/pipeline-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-run.d.ts","sourceRoot":"","sources":["../../src/tools/pipeline-run.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,2BAA2B,EACjC,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,cAAc,CAAC;AAkEtB,oEAAoE;AACpE,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,2BAA2B,EAChC,OAAO,GAAE,iBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DhC"}

package/dist/tools/pipeline-status.d.ts

@@ -0,0 +1,33 @@
+import { type ToolRegistrationHookContext } from "@sentry/junior-plugin-api";
+import { type GocdPluginOptions } from "../config.js";
+/** Return the current state for one GoCD pipeline. */
+export declare function createGocdPipelineStatusTool(ctx: ToolRegistrationHookContext, options?: GocdPluginOptions): import("@sentry/junior-plugin-api").PluginToolDefinition<{
+    pipeline: string;
+}, {
+    [x: string]: unknown;
+    target: "pipeline_status";
+    baseUrl: string;
+    pipeline: string;
+    paused: boolean;
+    locked: boolean;
+    schedulable: boolean;
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    target: "pipeline_status";
+    baseUrl: string;
+    pipeline: string;
+    paused: boolean;
+    locked: boolean;
+    schedulable: boolean;
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+}>;
+//# sourceMappingURL=pipeline-status.d.ts.map

package/dist/tools/pipeline-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-status.d.ts","sourceRoot":"","sources":["../../src/tools/pipeline-status.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,2BAA2B,EACjC,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,cAAc,CAAC;AA4BtB,sDAAsD;AACtD,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,2BAA2B,EAChC,OAAO,GAAE,iBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+ChC"}

package/dist/tools/pipelines.d.ts

@@ -0,0 +1,80 @@
+import { type ToolRegistrationHookContext } from "@sentry/junior-plugin-api";
+import { type GocdPluginOptions } from "../config.js";
+/** Return the pipelines visible to the current GoCD user with recent run state. */
+export declare function createGocdPipelinesTool(ctx: ToolRegistrationHookContext, options?: GocdPluginOptions): import("@sentry/junior-plugin-api").PluginToolDefinition<{
+    count: number;
+    query?: string | undefined;
+}, {
+    [x: string]: unknown;
+    target: "pipelines";
+    baseUrl: string;
+    pipelines: {
+        name: string;
+        lastUpdatedAt: number | null;
+        locked: boolean;
+        paused: boolean;
+        runs: {
+            label: string;
+            counter: number;
+            scheduledAt: string | null;
+            stages: {
+                name: string;
+                counter: string;
+                status: string;
+                scheduledAt: string | null;
+            }[];
+        }[];
+    }[];
+    environments: {
+        [x: string]: unknown;
+        name: string;
+        pipelines: string[];
+    }[];
+    pipelineGroups: {
+        [x: string]: unknown;
+        name: string;
+        pipelines: string[];
+    }[];
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    target: "pipelines";
+    baseUrl: string;
+    pipelines: {
+        name: string;
+        lastUpdatedAt: number | null;
+        locked: boolean;
+        paused: boolean;
+        runs: {
+            label: string;
+            counter: number;
+            scheduledAt: string | null;
+            stages: {
+                name: string;
+                counter: string;
+                status: string;
+                scheduledAt: string | null;
+            }[];
+        }[];
+    }[];
+    environments: {
+        [x: string]: unknown;
+        name: string;
+        pipelines: string[];
+    }[];
+    pipelineGroups: {
+        [x: string]: unknown;
+        name: string;
+        pipelines: string[];
+    }[];
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+}>;
+//# sourceMappingURL=pipelines.d.ts.map

package/dist/tools/pipelines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipelines.d.ts","sourceRoot":"","sources":["../../src/tools/pipelines.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,2BAA2B,EACjC,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,cAAc,CAAC;AA2FtB,mFAAmF;AACnF,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,2BAA2B,EAChC,OAAO,GAAE,iBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EhC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-gocd",
-  "version": "0.189.0",
+  "version": "0.191.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -22,8 +22,8 @@
     "skills"
   ],
   "dependencies": {
-    "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.189.0"
+    "zod": "^4.5.4",
+    "@sentry/junior-plugin-api": "0.191.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",

package/skills/gocd/SKILL.md

@@ -10,8 +10,6 @@ Use the GoCD tools for current pipeline and stage data.
 ## Rules
 
 - Treat GoCD access as read-only.
-- Use the exact pipeline name.
-- Use `pipelineHistory` to find recent pipeline runs.
-- Use `stage` when the user needs the jobs or failed job names for one stage run.
-- Do not claim that pipeline history includes console logs.
-- If a request fails, state whether GoCD rejected it or the app lacks a base URL or credentials.
+- Use the configured pipeline when the user does not name one.
+- Use `pipelines` to find pipeline names and `pipelineHistory` for recent runs.
+- Use the narrower run, stage, status, or job tool when the request needs it.