@sentry/junior-gocd 0.189.0

package/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,73 @@
+# @sentry/junior-gocd
+
+`@sentry/junior-gocd` adds read-only GoCD tools to Junior. The package does not contain settings for a specific GoCD deployment.
+
+## Install
+
+```ts
+import { defineJuniorPlugins } from "@sentry/junior";
+import { gocdPlugin } from "@sentry/junior-gocd";
+
+export const plugins = defineJuniorPlugins([
+  gocdPlugin({
+    // Optional. You can set GOCD_URL instead.
+    baseUrl: "https://gocd.example.com",
+  }),
+]);
+```
+
+## Configuration
+
+| Variable            | Required                  | Use                                                                 |
+| ------------------- | ------------------------- | ------------------------------------------------------------------- |
+| `GOCD_URL`          | when `baseUrl` is omitted | The HTTPS base URL for GoCD, such as `https://gocd.example.com`     |
+| `GOCD_ACCESS_TOKEN` | for token authentication  | A read-only GoCD API token used as the `Authorization` bearer token |
+
+The configured base URL cannot change during a tool call. Junior allows network access and adds credentials for the domain when it registers the plugin.
+
+For services such as Google IAP, the app can supply `grantForEgress` and `issueCredential` hooks instead of `GOCD_ACCESS_TOKEN`:
+
+```ts
+gocdPlugin({
+  baseUrl: "https://gocd.example.com",
+  hooks: {
+    grantForEgress() {
+      return {
+        access: "read",
+        name: "gocd-read",
+        reason: "read GoCD data",
+      };
+    },
+    async issueCredential() {
+      return {
+        type: "lease",
+        lease: {
+          expiresAt: new Date(Date.now() + 55 * 60_000).toISOString(),
+          headerTransforms: [
+            {
+              domain: "gocd.example.com",
+              headers: {
+                Authorization: "bearer ...",
+                "Proxy-Authorization": "Bearer ...",
+              },
+            },
+          ],
+        },
+      };
+    },
+  },
+});
+```
+
+## Tools
+
+- `pipelineHistory`: returns recent runs for one pipeline
+- `stage`: returns one stage run, its jobs, and failed job names
+
+The tools use the GoCD 25.2.0 API:
+
+- pipeline history: `GET /go/api/pipelines/:name/history` 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
+
+Keep pipeline names and other deployment-specific settings in the app that registers this plugin.

package/dist/config.d.ts

@@ -0,0 +1,15 @@
+/** GoCD connection settings supplied by the app. */
+export interface GocdPluginOptions {
+    /**
+     * Optional default GoCD base URL, for example `https://gocd.example.com`.
+     * When omitted, tools require `GOCD_URL`.
+     */
+    baseUrl?: string;
+}
+/** Return the hostname from a valid GoCD base URL. */
+export declare function hostnameFromBaseUrl(baseUrl: string): string;
+/** Resolve the absolute request URL for one GoCD API path. */
+export declare function resolveGocdApiUrl(baseUrl: string, path: string): string;
+/** Return the configured GoCD base URL. */
+export declare function resolveGocdBaseUrl(options?: GocdPluginOptions): string;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,oDAAoD;AAEpD,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AA0BD,sDAAsD;AACtD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,8DAA8D;AAC9D,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKvE;AAED,2CAA2C;AAC3C,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,iBAAsB,GAAG,MAAM,CAY1E"}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * GoCD plugin runtime boundary.
+ *
+ * This package owns general read-only GoCD tools. The app supplies the GoCD
+ * base URL and authentication. Keep deployment-specific settings in the app.
+ */
+import { type PluginHooks, type PluginRegistration } from "@sentry/junior-plugin-api";
+import { type GocdPluginOptions } from "./config.js";
+export type GocdCredentialHooks = Pick<PluginHooks, "grantForEgress" | "issueCredential" | "onEgressResponse">;
+export interface GocdPluginRegistrationOptions extends GocdPluginOptions {
+    /**
+     * Optional credential hooks supplied by the app.
+     * When omitted, Junior uses `GOCD_ACCESS_TOKEN` for the configured domain.
+     */
+    hooks?: GocdCredentialHooks;
+}
+/** Register read-only GoCD tools. */
+export declare function gocdPlugin(options?: GocdPluginRegistrationOptions): PluginRegistration;
+export { hostnameFromBaseUrl, resolveGocdApiUrl, resolveGocdBaseUrl, type GocdPluginOptions, } from "./config.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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"}

package/dist/index.js

@@ -0,0 +1,248 @@
+// src/index.ts
+import {
+  defineJuniorPlugin
+} from "@sentry/junior-plugin-api";
+
+// src/config.ts
+function parseBaseUrl(baseUrl) {
+  let url;
+  try {
+    url = new URL(baseUrl);
+  } catch {
+    throw new Error(`Invalid GoCD base URL: ${baseUrl}`);
+  }
+  if (url.protocol !== "https:") {
+    throw new Error("GoCD base URL must use https");
+  }
+  if (url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
+    throw new Error(
+      "GoCD base URL cannot include credentials, a path, a query, or a fragment"
+    );
+  }
+  return url;
+}
+function hostnameFromBaseUrl(baseUrl) {
+  return parseBaseUrl(baseUrl).hostname;
+}
+function resolveGocdApiUrl(baseUrl, path) {
+  if (!path.startsWith("/go/")) {
+    throw new Error("GoCD API paths must start with /go/");
+  }
+  return `${parseBaseUrl(baseUrl).origin}${path}`;
+}
+function resolveGocdBaseUrl(options = {}) {
+  const configuredBaseUrl = (options.baseUrl ?? process.env.GOCD_URL ?? "").trim();
+  if (!configuredBaseUrl) {
+    throw new Error(
+      "GoCD base URL is required. Configure gocdPlugin({ baseUrl }) or set GOCD_URL."
+    );
+  }
+  return parseBaseUrl(configuredBaseUrl).origin;
+}
+
+// src/tools/pipeline-history.ts
+import {
+  definePluginTool,
+  pluginToolOutputSchema
+} from "@sentry/junior-plugin-api";
+import { z } from "zod";
+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)
+}).strict();
+var outputSchema = pluginToolOutputSchema.extend({
+  target: z.literal("pipeline_history"),
+  baseUrl: z.string(),
+  pipeline: z.string(),
+  runs: z.array(z.unknown())
+});
+function createGocdPipelineHistoryTool(ctx, options = {}) {
+  return definePluginTool({
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+      readOnlyHint: true
+    },
+    description: "Fetch recent runs for an exact GoCD pipeline. Use this to inspect deployment history and stage or job results.",
+    inputSchema,
+    outputSchema,
+    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.pipeline.history",
+        provider: "gocd",
+        request: new Request(
+          resolveGocdApiUrl(
+            baseUrl,
+            `/go/api/pipelines/${encodeURIComponent(input.pipeline)}/history?page_size=${pageSize}`
+          ),
+          {
+            headers: {
+              Accept: "application/vnd.go.cd.v1+json"
+            },
+            method: "GET"
+          }
+        )
+      });
+      if (!response.ok) {
+        throw new Error(
+          `GoCD pipeline history failed with HTTP ${response.status}`
+        );
+      }
+      const body = z.object({ pipelines: z.array(z.unknown()) }).passthrough().parse(await response.json());
+      return {
+        baseUrl,
+        pipeline: input.pipeline,
+        runs: body.pipelines.slice(0, input.count),
+        target: "pipeline_history"
+      };
+    }
+  });
+}
+
+// src/tools/stage.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."),
+  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).")
+}).strict();
+var jobSchema = z2.object({
+  name: z2.string(),
+  result: z2.string().optional(),
+  state: z2.string().optional()
+}).passthrough();
+var stageBodySchema = z2.object({
+  result: z2.string().optional(),
+  _embedded: z2.object({ jobs: z2.array(jobSchema).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() })
+  ),
+  failedJobs: z2.array(z2.string())
+});
+function createGocdStageTool(ctx, options = {}) {
+  return definePluginTool2({
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+      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,
+    async execute(input) {
+      const baseUrl = resolveGocdBaseUrl(options);
+      const path = `/go/api/stages/${encodeURIComponent(input.pipeline)}/${encodeURIComponent(input.stage)}/instance/${input.pipelineCounter}/${input.stageCounter}`;
+      const response = await ctx.egress.fetch({
+        operation: "gocd.stage",
+        provider: "gocd",
+        request: new Request(resolveGocdApiUrl(baseUrl, path), {
+          headers: { Accept: "application/vnd.go.cd.v3+json" },
+          method: "GET"
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`GoCD stage failed with HTTP ${response.status}`);
+      }
+      const body = stageBodySchema.parse(await response.json());
+      const jobs = body._embedded.jobs.map((job) => ({
+        name: job.name,
+        result: job.result ?? "Unknown",
+        state: job.state ?? "Unknown"
+      }));
+      const link = resolveGocdApiUrl(
+        baseUrl,
+        `/go/pipelines/${encodeURIComponent(input.pipeline)}/${input.pipelineCounter}/${encodeURIComponent(input.stage)}/${input.stageCounter}`
+      );
+      return {
+        target: "stage",
+        baseUrl,
+        link,
+        pipeline: input.pipeline,
+        pipelineCounter: input.pipelineCounter,
+        stage: input.stage,
+        stageCounter: input.stageCounter,
+        result: body.result ?? "Unknown",
+        jobs,
+        failedJobs: jobs.filter((job) => job.result === "Failed").map((job) => job.name)
+      };
+    }
+  });
+}
+
+// src/index.ts
+function resolveManifestHostname(options) {
+  const baseUrl = (options.baseUrl ?? process.env.GOCD_URL ?? "").trim();
+  if (!baseUrl) return void 0;
+  return hostnameFromBaseUrl(baseUrl);
+}
+function gocdPlugin(options = {}) {
+  const hostname = resolveManifestHostname(options);
+  const credentialHooks = options.hooks;
+  const usesCredentialHooks = Boolean(
+    credentialHooks?.grantForEgress || credentialHooks?.issueCredential
+  );
+  const manifest = {
+    description: "Read GoCD pipeline and stage results",
+    displayName: "GoCD",
+    envVars: {
+      GOCD_ACCESS_TOKEN: {},
+      GOCD_URL: {}
+    },
+    name: "gocd"
+  };
+  if (hostname) {
+    manifest.domains = [hostname];
+    if (!usesCredentialHooks) {
+      manifest.apiHeaders = {
+        Authorization: "bearer ${GOCD_ACCESS_TOKEN}"
+      };
+    }
+  }
+  const hooks = {
+    tools(ctx) {
+      return {
+        pipelineHistory: createGocdPipelineHistoryTool(ctx, options),
+        stage: createGocdStageTool(ctx, options)
+      };
+    }
+  };
+  if (credentialHooks?.grantForEgress) {
+    hooks.grantForEgress = credentialHooks.grantForEgress;
+  }
+  if (credentialHooks?.issueCredential) {
+    hooks.issueCredential = credentialHooks.issueCredential;
+  }
+  if (credentialHooks?.onEgressResponse) {
+    hooks.onEgressResponse = credentialHooks.onEgressResponse;
+  }
+  return defineJuniorPlugin({
+    packageName: "@sentry/junior-gocd",
+    manifest,
+    hooks
+  });
+}
+export {
+  gocdPlugin,
+  hostnameFromBaseUrl,
+  resolveGocdApiUrl,
+  resolveGocdBaseUrl
+};

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

@@ -0,0 +1,35 @@
+import { type ToolRegistrationHookContext } from "@sentry/junior-plugin-api";
+import { type GocdPluginOptions } from "../config.js";
+/**
+ * Return recent runs for one GoCD pipeline.
+ *
+ * Uses GoCD 25.2.0 `GET /go/api/pipelines/:name/history` with Accept v1.
+ * `page_size` must stay in 10..100. Smaller counts are clamped, then sliced.
+ */
+export declare function createGocdPipelineHistoryTool(ctx: ToolRegistrationHookContext, options?: GocdPluginOptions): import("@sentry/junior-plugin-api").PluginToolDefinition<{
+    pipeline: string;
+    count: number;
+}, {
+    [x: string]: unknown;
+    target: "pipeline_history";
+    baseUrl: string;
+    pipeline: string;
+    runs: unknown[];
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    target: "pipeline_history";
+    baseUrl: string;
+    pipeline: string;
+    runs: unknown[];
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+}>;
+//# sourceMappingURL=pipeline-history.d.ts.map

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

@@ -0,0 +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"}

package/dist/tools/stage.d.ts

@@ -0,0 +1,52 @@
+import { type ToolRegistrationHookContext } from "@sentry/junior-plugin-api";
+import { type GocdPluginOptions } from "../config.js";
+/** Return one exact GoCD stage run and its jobs. */
+export declare function createGocdStageTool(ctx: ToolRegistrationHookContext, options?: GocdPluginOptions): import("@sentry/junior-plugin-api").PluginToolDefinition<{
+    pipeline: string;
+    pipelineCounter: number;
+    stage: string;
+    stageCounter: number;
+}, {
+    [x: string]: unknown;
+    target: "stage";
+    baseUrl: string;
+    link: string;
+    pipeline: string;
+    pipelineCounter: number;
+    stage: string;
+    stageCounter: number;
+    result: string;
+    jobs: {
+        name: string;
+        result: string;
+        state: string;
+    }[];
+    failedJobs: string[];
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    target: "stage";
+    baseUrl: string;
+    link: string;
+    pipeline: string;
+    pipelineCounter: number;
+    stage: string;
+    stageCounter: number;
+    result: string;
+    jobs: {
+        name: string;
+        result: string;
+        state: string;
+    }[];
+    failedJobs: string[];
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+}>;
+//# sourceMappingURL=stage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stage.d.ts","sourceRoot":"","sources":["../../src/tools/stage.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,2BAA2B,EACjC,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,cAAc,CAAC;AAoEtB,oDAAoD;AACpD,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,2BAA2B,EAChC,OAAO,GAAE,iBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DhC"}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@sentry/junior-gocd",
+  "version": "0.189.0",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/getsentry/junior.git",
+    "directory": "packages/junior-gocd"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "skills"
+  ],
+  "dependencies": {
+    "zod": "^4.4.3",
+    "@sentry/junior-plugin-api": "0.189.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "oxlint": "^1.66.0",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7"
+  },
+  "scripts": {
+    "build": "tsup && tsc -p tsconfig.build.json --emitDeclarationOnly",
+    "lint": "oxlint --config ../junior/.oxlintrc.json --deny-warnings src tests tsup.config.ts vitest.config.ts",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/skills/gocd/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: gocd
+description: Read GoCD pipeline and stage results. Use when users ask about GoCD pipeline runs, deployment failures, run history, stages, or jobs.
+---
+
+# GoCD
+
+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.

package/skills/gocd/SOURCES.md

@@ -0,0 +1,4 @@
+# Sources
+
+- GoCD user docs (25.2.0): https://docs.gocd.org/25.2.0/
+- GoCD API reference (25.2.0): https://api.gocd.org/25.2.0/