@sentry/junior-vercel 0.135.0 → 0.136.0

package/README.md

@@ -45,7 +45,13 @@ The endpoint must be publicly reachable. Subscribe it to `deployment.succeeded`,
 
 Deployment watches use Vercel's canonical `prj_...` ID. Junior resolves that ID from the project name or ID and optional team slug or ID through Vercel's authenticated project API.
 
-Create the conversation watch before the terminal deployment event. A valid webhook delivery does not create a watch by itself, and unmatched deliveries are not replayed later.
+Supported scopes (`deployment` resource type):
+
+- `prj_...` for every deployment in the project
+- `prj_...:production` for every production deployment
+- `prj_...:production:<sha>` for one commit-scoped deployment
+
+Create the conversation watch or event task before the terminal deployment event. A valid webhook delivery does not create a watch by itself, and unmatched deliveries are not replayed later.
 
 ## Auth model
 

package/dist/{chunk-5ZQCPWW4.js → chunk-JPFMGGYE.js}

@@ -1,24 +1,42 @@
-// src/resource-events/deployment-source.ts
+// src/resource-events/deployment.ts
 var VERCEL_DEPLOYMENT_EVENTS = [
   "deployment.succeeded",
   "deployment.error",
   "deployment.canceled"
 ];
-function vercelDeploymentSourceResource(input) {
-  const commitSha2 = input.commitSha.toLowerCase();
+var VERCEL_DEPLOYMENT_SUGGESTED_EVENTS = [
+  "deployment.succeeded",
+  "deployment.error",
+  "deployment.canceled"
+];
+function vercelDeploymentResource(input) {
+  const commitSha2 = input.commitSha?.toLowerCase();
+  const target = input.target;
+  const parts = [input.projectId];
+  if (target) parts.push(target);
+  if (commitSha2) parts.push(commitSha2);
+  let label;
+  if (target && commitSha2) {
+    label = `Vercel ${target} deployment for ${input.projectId} at ${commitSha2.slice(0, 12)}`;
+  } else if (target) {
+    label = `Vercel ${target} deployments for ${input.projectId}`;
+  } else {
+    label = `Vercel deployments for ${input.projectId}`;
+  }
   return {
-    label: `Vercel ${input.target} deployment for ${input.projectId} at ${commitSha2.slice(0, 12)}`,
+    label,
     namespace: "vercel",
-    identifier: `deployment-source:${input.projectId}:${input.target}:${commitSha2}`
+    identifier: parts.join(":")
   };
 }
-function vercelDeploymentSourceSubscribable(input) {
+function vercelDeploymentSubscribable(input) {
   if (!input.webhookSecret) return void 0;
+  if (input.commitSha && !input.target) return void 0;
   return {
-    ...vercelDeploymentSourceResource(input),
-    suggestedEvents: [...VERCEL_DEPLOYMENT_EVENTS],
+    ...vercelDeploymentResource(input),
+    suggestedEvents: VERCEL_DEPLOYMENT_SUGGESTED_EVENTS,
     supportedEvents: [...VERCEL_DEPLOYMENT_EVENTS],
-    type: "deployment_source"
+    type: "deployment"
   };
 }
 
@@ -27,7 +45,7 @@ function vercelWebhookSecret() {
   return process.env.VERCEL_WEBHOOK_SECRET?.trim() || void 0;
 }
 
-// src/tools/deployment-source.ts
+// src/tools/deployment.ts
 import {
   definePluginTool,
   pluginToolOutputSchema,
@@ -39,20 +57,24 @@ var commitShaSchema = z.string().regex(/^[0-9a-f]{40}$/i);
 var targetSchema = z.enum(["preview", "production", "staging"]);
 var nonEmptyStringSchema = z.string().trim().min(1);
 var inputSchema = z.object({
-  commitSha: commitShaSchema.describe("Full 40-character Git commit SHA."),
+  commitSha: commitShaSchema.describe(
+    "Optional full 40-character Git commit SHA. Provide it to watch one deployment; omit it to watch every matching deployment for the project."
+  ).optional(),
   project: nonEmptyStringSchema.describe("Vercel project name or prj_ ID."),
-  target: targetSchema.describe("Deployment target to monitor.").default("production"),
+  target: targetSchema.describe(
+    'Optional deployment target such as "production". Omit to watch every target for the project. Defaults to "production" when commitSha is set.'
+  ).optional(),
   team: nonEmptyStringSchema.describe("Optional Vercel team slug or team_ ID that owns the project.").optional()
 }).strict();
-var deploymentSourceSchema = z.object({
-  commitSha: commitShaSchema,
-  deploymentTarget: targetSchema,
+var deploymentSchema = z.object({
+  commitSha: commitShaSchema.nullable(),
+  deploymentTarget: targetSchema.nullable(),
   projectId: projectIdSchema,
   subscribable: subscribableResourceSchema.optional()
 });
 var outputSchema = pluginToolOutputSchema.extend({
-  target: z.literal("deploymentSource"),
-  ...deploymentSourceSchema.shape
+  target: z.literal("deployment"),
+  ...deploymentSchema.shape
 });
 async function readJson(response) {
   const text = await response.text();
@@ -72,7 +94,7 @@ function projectLookupUrl(project, team) {
   }
   return url.toString();
 }
-function createVercelDeploymentSourceTool(ctx) {
+function createVercelDeploymentTool(ctx) {
   return definePluginTool({
     annotations: {
       destructiveHint: false,
@@ -80,7 +102,7 @@ function createVercelDeploymentSourceTool(ctx) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    description: "Resolve a Vercel project name or ID and describe its deployment target and full Git commit SHA as a subscribable deployment source. Use the user's explicit project and team, otherwise the vercel.project and vercel.team conversation defaults. Use this after the final deployed commit is known and before waiting for a deployment outcome.",
+    description: "Resolve a Vercel project name or ID and describe a subscribable deployment resource. Omit commitSha to watch every deployment for the project, optionally limited to one target (production, preview, or staging). Provide commitSha to watch one deployment; target defaults to production when omitted with commitSha. Use the user's explicit project and team, otherwise the vercel.project and vercel.team conversation defaults.",
     inputSchema,
     outputSchema,
     async execute(input) {
@@ -96,21 +118,22 @@ function createVercelDeploymentSourceTool(ctx) {
         );
       }
       const projectId = z.object({ id: projectIdSchema }).parse(parsed).id;
-      const commitSha2 = input.commitSha.toLowerCase();
-      const subscribable = ctx.resourceEvents.canSubscribe ? vercelDeploymentSourceSubscribable({
+      const commitSha2 = input.commitSha?.toLowerCase();
+      const deploymentTarget2 = input.target ?? (commitSha2 ? "production" : void 0);
+      const subscribable = ctx.resourceEvents.canSubscribe ? vercelDeploymentSubscribable({
         commitSha: commitSha2,
         projectId,
-        target: input.target,
+        target: deploymentTarget2,
         webhookSecret: vercelWebhookSecret()
       }) : void 0;
       const data = {
-        commitSha: commitSha2,
-        deploymentTarget: input.target,
+        commitSha: commitSha2 ?? null,
+        deploymentTarget: deploymentTarget2 ?? null,
         projectId,
         ...subscribable ? { subscribable } : {}
       };
       return {
-        target: "deploymentSource",
+        target: "deployment",
         ...data
       };
     }
@@ -175,32 +198,63 @@ function isDeploymentEvent(value) {
     value
   );
 }
+function deploymentTargets(input) {
+  const targets = [
+    {
+      completeOnTerminalEvent: false,
+      resource: vercelDeploymentResource({
+        projectId: input.projectId
+      })
+    },
+    {
+      completeOnTerminalEvent: false,
+      resource: vercelDeploymentResource({
+        projectId: input.projectId,
+        target: input.target
+      })
+    }
+  ];
+  if (input.commitSha) {
+    targets.push({
+      completeOnTerminalEvent: true,
+      resource: vercelDeploymentResource({
+        commitSha: input.commitSha,
+        projectId: input.projectId,
+        target: input.target
+      })
+    });
+  }
+  return targets;
+}
 function normalizeVercelResourceEvents(args) {
   const envelope = webhookEnvelopeSchema.safeParse(args.body);
   if (!envelope.success || !isDeploymentEvent(envelope.data.type)) return [];
   const payload = deploymentPayloadSchema.safeParse(envelope.data.payload);
   if (!payload.success) return [];
   const target = payload.data.target;
-  const sha = payload.data.commitSha;
-  if (!target || !sha) return [];
-  const resource = vercelDeploymentSourceResource({
-    commitSha: sha,
-    projectId: payload.data.projectId,
-    target
-  });
+  if (!target) return [];
   const eventType = envelope.data.type;
   const deploymentId = payload.data.deploymentId;
   const outcome = eventType === "deployment.succeeded" ? "succeeded" : eventType === "deployment.error" ? "failed" : "was canceled";
-  return [
-    {
-      eventKey: `vercel:${envelope.data.id}:${eventType}`,
-      eventType,
-      occurredAtMs: envelope.data.createdAt,
-      identifier: resource.identifier,
-      terminal: true,
-      trustedSummary: `${resource.label} (${deploymentId}) ${outcome}.`
-    }
-  ];
+  const untrustedParts = [
+    `Target: ${target}`,
+    payload.data.commitSha ? `Commit: ${payload.data.commitSha}` : void 0,
+    `Deployment: ${deploymentId}`
+  ].filter((part) => part !== void 0);
+  const untrustedText = untrustedParts.join("\n");
+  return deploymentTargets({
+    commitSha: payload.data.commitSha,
+    projectId: payload.data.projectId,
+    target
+  }).map(({ completeOnTerminalEvent, resource }) => ({
+    eventKey: `vercel:${envelope.data.id}:${eventType}`,
+    eventType,
+    occurredAtMs: envelope.data.createdAt,
+    identifier: resource.identifier,
+    ...completeOnTerminalEvent ? { terminal: true } : {},
+    trustedSummary: `${resource.label} (${deploymentId}) ${outcome}.`,
+    untrustedText
+  }));
 }
 
 // src/webhooks/handler.ts
@@ -247,8 +301,9 @@ function createVercelWebhookRoute(args) {
 
 export {
   VERCEL_DEPLOYMENT_EVENTS,
+  VERCEL_DEPLOYMENT_SUGGESTED_EVENTS,
   vercelWebhookSecret,
-  createVercelDeploymentSourceTool,
+  createVercelDeploymentTool,
   normalizeVercelResourceEvents,
   createVercelWebhookRoute
 };

package/dist/index.d.ts

@@ -2,8 +2,8 @@
  * Vercel plugin runtime boundary.
  *
  * This package owns Vercel CLI setup, host-managed API authentication, signed
- * webhook normalization, and deployment-source tools. Junior core owns the
- * resulting conversation subscriptions and event delivery.
+ * webhook normalization, and deployment tools. Junior core owns the resulting
+ * conversation subscriptions and event delivery.
  */
 import { type PluginRegistration } from "@sentry/junior-plugin-api";
 /** Register Vercel runtime metadata, tools, and signed webhook ingress. */

package/dist/index.js

@@ -1,9 +1,10 @@
 import {
   VERCEL_DEPLOYMENT_EVENTS,
-  createVercelDeploymentSourceTool,
+  VERCEL_DEPLOYMENT_SUGGESTED_EVENTS,
+  createVercelDeploymentTool,
   createVercelWebhookRoute,
   vercelWebhookSecret
-} from "./chunk-5ZQCPWW4.js";
+} from "./chunk-JPFMGGYE.js";
 
 // src/index.ts
 import {
@@ -15,9 +16,9 @@ function vercelPlugin() {
     resourceEvents: {
       resourceTypes: [
         {
-          type: "deployment_source",
+          type: "deployment",
           supportedEvents: [...VERCEL_DEPLOYMENT_EVENTS],
-          suggestedEvents: [...VERCEL_DEPLOYMENT_EVENTS]
+          suggestedEvents: [...VERCEL_DEPLOYMENT_SUGGESTED_EVENTS]
         }
       ],
       isEnabled: () => Boolean(vercelWebhookSecret())
@@ -57,7 +58,7 @@ function vercelPlugin() {
       },
       tools(ctx) {
         return {
-          deploymentSource: createVercelDeploymentSourceTool(ctx)
+          deployment: createVercelDeploymentTool(ctx)
         };
       }
     }

package/dist/resource-events/deployment.d.ts

@@ -0,0 +1,17 @@
+import type { SubscribableResource } from "@sentry/junior-plugin-api";
+export declare const VERCEL_DEPLOYMENT_EVENTS: readonly ["deployment.succeeded", "deployment.error", "deployment.canceled"];
+export declare const VERCEL_DEPLOYMENT_SUGGESTED_EVENTS: string[];
+export type VercelDeploymentTarget = "preview" | "production" | "staging";
+/** Build the stable deployment identity shared by tools and webhooks. */
+export declare function vercelDeploymentResource(input: {
+    commitSha?: string;
+    projectId: string;
+    target?: VercelDeploymentTarget;
+}): Pick<SubscribableResource, "label" | "namespace" | "identifier">;
+/** Describe a deployment resource when signed Vercel webhooks are enabled. */
+export declare function vercelDeploymentSubscribable(input: {
+    commitSha?: string;
+    projectId: string;
+    target?: VercelDeploymentTarget;
+    webhookSecret?: string;
+}): SubscribableResource | undefined;

package/dist/testing.d.ts

@@ -1,3 +1,3 @@
-export { createVercelDeploymentSourceTool } from "./tools/deployment-source.js";
+export { createVercelDeploymentTool } from "./tools/deployment.js";
 export { createVercelWebhookRoute } from "./webhooks/handler.js";
 export { normalizeVercelResourceEvents } from "./webhooks/resource-events.js";

package/dist/testing.js

@@ -1,10 +1,10 @@
 import {
-  createVercelDeploymentSourceTool,
+  createVercelDeploymentTool,
   createVercelWebhookRoute,
   normalizeVercelResourceEvents
-} from "./chunk-5ZQCPWW4.js";
+} from "./chunk-JPFMGGYE.js";
 export {
-  createVercelDeploymentSourceTool,
+  createVercelDeploymentTool,
   createVercelWebhookRoute,
   normalizeVercelResourceEvents
 };

package/dist/tools/{deployment-source.d.ts → deployment.d.ts}

@@ -1,16 +1,16 @@
 import { type ToolRegistrationHookContext } from "@sentry/junior-plugin-api";
-/** Resolve and return the resource identity for one Vercel deployment source. */
-export declare function createVercelDeploymentSourceTool(ctx: ToolRegistrationHookContext): import("@sentry/junior-plugin-api").PluginToolDefinition<{
-    commitSha: string;
+/** Resolve and return the resource identity for one Vercel deployment. */
+export declare function createVercelDeploymentTool(ctx: ToolRegistrationHookContext): import("@sentry/junior-plugin-api").PluginToolDefinition<{
     project: string;
-    target: "preview" | "production" | "staging";
+    commitSha?: string | undefined;
+    target?: "preview" | "production" | "staging" | undefined;
     team?: string | undefined;
 }, {
     [x: string]: unknown;
-    commitSha: string;
-    deploymentTarget: "preview" | "production" | "staging";
+    commitSha: string | null;
+    deploymentTarget: "preview" | "production" | "staging" | null;
     projectId: string;
-    target: "deploymentSource";
+    target: "deployment";
     truncated?: boolean | undefined;
     continuation?: {
         arguments: Record<string, unknown>;
@@ -26,10 +26,10 @@ export declare function createVercelDeploymentSourceTool(ctx: ToolRegistrationHo
     } | undefined;
 }, {
     [x: string]: unknown;
-    commitSha: string;
-    deploymentTarget: "preview" | "production" | "staging";
+    commitSha: string | null;
+    deploymentTarget: "preview" | "production" | "staging" | null;
     projectId: string;
-    target: "deploymentSource";
+    target: "deployment";
     truncated?: boolean | undefined;
     continuation?: {
         arguments: Record<string, unknown>;

package/dist/webhooks/resource-events.d.ts

@@ -2,10 +2,10 @@
  * Owns Vercel's deployment webhook wire-format boundary.
  *
  * It validates webhook payloads, ignores unsupported or incomplete deliveries,
- * and emits only canonical terminal resource events.
+ * and emits canonical resource events for project, target, and commit watches.
  */
 import type { ResourceEventInput } from "@sentry/junior-plugin-api";
-/** Normalize one verified Vercel delivery into a terminal deployment event. */
+/** Normalize one verified Vercel delivery into deployment resource events. */
 export declare function normalizeVercelResourceEvents(args: {
     body: unknown;
 }): ResourceEventInput[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-vercel",
-  "version": "0.135.0",
+  "version": "0.136.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -27,7 +27,7 @@
   ],
   "dependencies": {
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.135.0"
+    "@sentry/junior-plugin-api": "0.136.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",

package/skills/vercel/SKILL.md

@@ -37,7 +37,7 @@ Do not run `deploy`, `rollback`, `promote`, `remove`, `env`, `alias`, `dns`, `pr
 - For runtime logs, prefer `vercel logs --project <project> --since <window> --limit 20 --json` plus user-provided filters such as `--environment`, `--level`, `--status-code`, `--source`, `--query`, or `--deployment`.
 - Use `vercel inspect <deployment-id-or-url> --logs` for build logs. Add `--wait` only when the user explicitly wants to wait for an active build; also bound it with `--timeout`.
 - Use `vercel list <project>` or `vercel ls <project>` to find deployments. Prefer filters such as `--status`, `--environment`, `--prod`, or `--meta githubCommitSha=<sha>` when available.
-- For a deployment watch, call the `vercel_deploymentSource` plugin tool with the project name, optional team slug or ID, deployment target, and full 40-character commit SHA. The tool resolves the canonical project ID through Vercel before Junior creates the conversation subscription.
+- For a deployment watch or event task, call the `vercel_deployment` plugin tool with the project name and optional team slug or ID. Omit `commitSha` to watch every deployment for the project; add `target` (`production`, `preview`, or `staging`) to limit the watch to one environment; add a full 40-character `commitSha` to watch one deployment (`target` defaults to `production` when omitted with a commit). The tool resolves the canonical project ID through Vercel before Junior creates the conversation subscription or event task.
 - Use `--follow` only when the user asks for live logs, and stop once enough evidence is captured. Do not leave a streaming command running indefinitely.
 
 3. Bound and minimize output:

package/dist/resource-events/deployment-source.d.ts

@@ -1,16 +0,0 @@
-import type { SubscribableResource } from "@sentry/junior-plugin-api";
-export declare const VERCEL_DEPLOYMENT_EVENTS: readonly ["deployment.succeeded", "deployment.error", "deployment.canceled"];
-export type VercelDeploymentTarget = "preview" | "production" | "staging";
-/** Build the stable deployment-source identity shared by tools and webhooks. */
-export declare function vercelDeploymentSourceResource(input: {
-    commitSha: string;
-    projectId: string;
-    target: VercelDeploymentTarget;
-}): Pick<SubscribableResource, "label" | "namespace" | "identifier">;
-/** Describe a deployment source when signed Vercel webhooks are enabled. */
-export declare function vercelDeploymentSourceSubscribable(input: {
-    commitSha: string;
-    projectId: string;
-    target: VercelDeploymentTarget;
-    webhookSecret?: string;
-}): SubscribableResource | undefined;