@sentry/junior-github 0.106.0 → 0.107.1

package/README.md

@@ -23,3 +23,7 @@ export const plugins = defineJuniorPlugins([
 ```
 
 Full setup guide: https://junior.sentry.dev/extend/github-plugin/
+
+The plugin owns its signed webhook route, normalized pull request outcome
+projection, and dashboard operational report. Core only owns delivery from
+plugin-published resource events into matching conversation subscriptions.

package/SETUP.md

@@ -36,6 +36,8 @@ Set on the harness host (never in skill files):
 - `GITHUB_APP_CLIENT_SECRET`
 - `GITHUB_APP_PRIVATE_KEY`
 - `GITHUB_INSTALLATION_ID`
+- `GITHUB_APP_BOT_NAME` (Git author and committer display name)
+- `GITHUB_APP_BOT_EMAIL`
 
 Current limitation: one Junior deployment uses one GitHub App installation ID.
 That works for repositories covered by the same installation, but not for repositories that live
@@ -53,6 +55,8 @@ vercel env add GITHUB_APP_ID production
 vercel env add GITHUB_APP_CLIENT_ID production
 vercel env add GITHUB_APP_CLIENT_SECRET production
 vercel env add GITHUB_INSTALLATION_ID production
+vercel env add GITHUB_APP_BOT_NAME production
+vercel env add GITHUB_APP_BOT_EMAIL production
 vercel env add GITHUB_APP_PRIVATE_KEY production --sensitive < ./github-app-private-key.pem
 ```
 
@@ -64,6 +68,32 @@ vercel env update GITHUB_APP_PRIVATE_KEY production --sensitive < ./github-app-p
 
 Repeat for `preview` and `development` as needed. After env changes, redeploy so the new deployment picks up updated values.
 
+### Optional pull request webhooks and outcome reporting
+
+To report Junior-created PR outcomes, use the standard GitHub noreply format
+`<bot-user-id>+<app-slug>[bot]@users.noreply.github.com` for
+`GITHUB_APP_BOT_EMAIL` and configure `GITHUB_WEBHOOK_SECRET`. Junior derives
+the App bot login from that email. Set the GitHub App webhook URL to
+`https://<junior-host>/api/webhooks/github` and subscribe to Pull request
+events. The secret in GitHub must match the deployment environment.
+
+Conversation watches additionally use Check suite, Issue comment, Pull request
+review, and Pull request review comment events.
+
+```bash
+vercel env add GITHUB_WEBHOOK_SECRET production
+```
+
+After installing or upgrading the plugin, apply its packaged migration from the
+deployed app environment:
+
+```bash
+pnpm exec junior upgrade
+```
+
+The migration creates `junior_github_pull_requests`, which backs webhook
+ingestion and the `/system` outcome report.
+
 ### Optional permission declaration
 
 By default, `installation-read` grants read the app installation's current permission envelope once per process and scopes read-capable permissions down to `read` when requesting a token. To declare the GitHub App permission envelope in the plugin and avoid that installation lookup, pass `appPermissions` when registering the plugin:
@@ -189,6 +219,8 @@ jr-rpc config set github.repo getsentry/junior
    - `GITHUB_APP_CLIENT_SECRET`
    - `GITHUB_APP_PRIVATE_KEY`
    - `GITHUB_INSTALLATION_ID`
+   - `GITHUB_APP_BOT_NAME`
+   - `GITHUB_APP_BOT_EMAIL`
 2. Confirm the GitHub App is installed on your test repo with the permissions above.
 3. Deploy `main` to prod.
 4. Exercise `github-issues` to create an issue in a safe test repo.

package/dist/chunk-JDNXIBCQ.js

@@ -0,0 +1,239 @@
+// src/webhooks/resource-events.ts
+import { z } from "zod";
+
+// src/resource-events/pull-request.ts
+var SUPPORTED_EVENTS = [
+  "checks.failed",
+  "checks.recovered",
+  "comment.created",
+  "review.approved",
+  "review.changes_requested",
+  "review.commented",
+  "review_comment.created",
+  "state.merged",
+  "state.closed_unmerged"
+];
+var SUGGESTED_EVENTS = [
+  "checks.failed",
+  "comment.created",
+  "review.changes_requested",
+  "review.commented",
+  "review_comment.created",
+  "state.merged",
+  "state.closed_unmerged"
+];
+function gitHubPullRequestResource(input) {
+  return {
+    label: `GitHub PR ${input.repo}#${input.number}`,
+    provider: "github",
+    resourceRef: `github:pull_request:${input.repo}#${input.number}`
+  };
+}
+function gitHubPullRequestSubscribable(input) {
+  if (!process.env.GITHUB_WEBHOOK_SECRET?.trim()) return void 0;
+  return {
+    ...gitHubPullRequestResource(input),
+    suggestedEvents: SUGGESTED_EVENTS,
+    supportedEvents: SUPPORTED_EVENTS,
+    type: "pull_request"
+  };
+}
+
+// src/webhooks/resource-events.ts
+function gitHubEventKey(deliveryId, eventType) {
+  return `github:${deliveryId}:${eventType}`;
+}
+var repositorySchema = z.object({ full_name: z.string().min(1) });
+var checkSuiteWebhookSchema = z.object({
+  action: z.string(),
+  check_suite: z.object({
+    conclusion: z.string().optional().nullable(),
+    head_sha: z.string().optional(),
+    pull_requests: z.array(z.object({ number: z.number() }))
+  }),
+  repository: repositorySchema
+});
+function normalizeCheckSuiteEvents(deliveryId, body) {
+  const parsed = checkSuiteWebhookSchema.safeParse(body);
+  if (!parsed.success || parsed.data.action !== "completed") return [];
+  const conclusion = parsed.data.check_suite.conclusion;
+  const eventType = conclusion === "failure" || conclusion === "timed_out" ? "checks.failed" : conclusion === "success" ? "checks.recovered" : void 0;
+  if (!eventType) return [];
+  const sha = parsed.data.check_suite.head_sha?.slice(0, 12);
+  return parsed.data.check_suite.pull_requests.map((pullRequest) => {
+    const resource = gitHubPullRequestResource({
+      number: pullRequest.number,
+      repo: parsed.data.repository.full_name
+    });
+    return {
+      eventKey: gitHubEventKey(
+        deliveryId,
+        `${eventType}:${pullRequest.number}`
+      ),
+      eventType,
+      occurredAtMs: Date.now(),
+      provider: "github",
+      resourceRef: resource.resourceRef,
+      trustedSummary: eventType === "checks.failed" ? `${resource.label} checks failed${sha ? ` for ${sha}` : ""}.` : `${resource.label} checks recovered${sha ? ` for ${sha}` : ""}.`
+    };
+  });
+}
+var issueCommentWebhookSchema = z.object({
+  action: z.string(),
+  comment: z.object({
+    body: z.string(),
+    user: z.object({ login: z.string().optional() }).optional()
+  }),
+  issue: z.object({
+    number: z.number(),
+    pull_request: z.object({ url: z.string().min(1) }).optional()
+  }),
+  repository: repositorySchema
+});
+function normalizeIssueCommentEvent(deliveryId, body) {
+  const parsed = issueCommentWebhookSchema.safeParse(body);
+  if (!parsed.success || parsed.data.action !== "created" || !parsed.data.issue.pull_request) {
+    return void 0;
+  }
+  const eventType = "comment.created";
+  const resource = gitHubPullRequestResource({
+    number: parsed.data.issue.number,
+    repo: parsed.data.repository.full_name
+  });
+  const author = parsed.data.comment.user?.login;
+  return {
+    eventKey: gitHubEventKey(deliveryId, eventType),
+    eventType,
+    occurredAtMs: Date.now(),
+    provider: "github",
+    resourceRef: resource.resourceRef,
+    trustedSummary: `${resource.label} received a comment${author ? ` from ${author}` : ""}.`,
+    untrustedText: parsed.data.comment.body
+  };
+}
+var pullRequestReviewCommentWebhookSchema = z.object({
+  action: z.string(),
+  comment: z.object({
+    body: z.string(),
+    user: z.object({ login: z.string().optional() }).optional()
+  }),
+  pull_request: z.object({ number: z.number() }),
+  repository: repositorySchema
+});
+function normalizePullRequestReviewCommentEvent(deliveryId, body) {
+  const parsed = pullRequestReviewCommentWebhookSchema.safeParse(body);
+  if (!parsed.success || parsed.data.action !== "created") return void 0;
+  const eventType = "review_comment.created";
+  const resource = gitHubPullRequestResource({
+    number: parsed.data.pull_request.number,
+    repo: parsed.data.repository.full_name
+  });
+  const author = parsed.data.comment.user?.login;
+  return {
+    eventKey: gitHubEventKey(deliveryId, eventType),
+    eventType,
+    occurredAtMs: Date.now(),
+    provider: "github",
+    resourceRef: resource.resourceRef,
+    trustedSummary: `${resource.label} received an inline review comment${author ? ` from ${author}` : ""}.`,
+    untrustedText: parsed.data.comment.body
+  };
+}
+var pullRequestReviewWebhookSchema = z.object({
+  action: z.string(),
+  pull_request: z.object({ number: z.number() }),
+  repository: repositorySchema,
+  review: z.object({
+    body: z.string().optional().nullable(),
+    state: z.string(),
+    user: z.object({ login: z.string().optional() }).optional()
+  })
+});
+function normalizePullRequestReviewEvent(deliveryId, body) {
+  const parsed = pullRequestReviewWebhookSchema.safeParse(body);
+  if (!parsed.success || parsed.data.action !== "submitted") return void 0;
+  const reviewState = parsed.data.review.state.toUpperCase();
+  const eventType = reviewState === "APPROVED" ? "review.approved" : reviewState === "CHANGES_REQUESTED" ? "review.changes_requested" : reviewState === "COMMENTED" ? "review.commented" : void 0;
+  if (!eventType) return void 0;
+  const resource = gitHubPullRequestResource({
+    number: parsed.data.pull_request.number,
+    repo: parsed.data.repository.full_name
+  });
+  const reviewer = parsed.data.review.user?.login;
+  return {
+    eventKey: gitHubEventKey(deliveryId, eventType),
+    eventType,
+    occurredAtMs: Date.now(),
+    provider: "github",
+    resourceRef: resource.resourceRef,
+    trustedSummary: eventType === "review.approved" ? `${resource.label} was approved${reviewer ? ` by ${reviewer}` : ""}.` : eventType === "review.changes_requested" ? `${resource.label} received requested changes${reviewer ? ` from ${reviewer}` : ""}.` : `${resource.label} received a review comment${reviewer ? ` from ${reviewer}` : ""}.`,
+    untrustedText: parsed.data.review.body ?? void 0
+  };
+}
+var pullRequestWebhookSchema = z.object({
+  action: z.string(),
+  pull_request: z.object({
+    closed_at: z.string().optional().nullable(),
+    merged: z.boolean().optional(),
+    merged_at: z.string().optional().nullable(),
+    number: z.number()
+  }),
+  repository: repositorySchema
+});
+function providerTime(value) {
+  if (!value) return void 0;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function normalizePullRequestEvent(deliveryId, body) {
+  const parsed = pullRequestWebhookSchema.safeParse(body);
+  if (!parsed.success || parsed.data.action !== "closed") return void 0;
+  const eventType = parsed.data.pull_request.merged ? "state.merged" : "state.closed_unmerged";
+  const resource = gitHubPullRequestResource({
+    number: parsed.data.pull_request.number,
+    repo: parsed.data.repository.full_name
+  });
+  return {
+    eventKey: gitHubEventKey(deliveryId, eventType),
+    eventType,
+    occurredAtMs: providerTime(
+      parsed.data.pull_request.merged ? parsed.data.pull_request.merged_at : parsed.data.pull_request.closed_at
+    ) ?? Date.now(),
+    provider: "github",
+    resourceRef: resource.resourceRef,
+    terminal: true,
+    trustedSummary: eventType === "state.merged" ? `${resource.label} was merged.` : `${resource.label} was closed without being merged.`
+  };
+}
+function normalizeGitHubResourceEvents(args) {
+  switch (args.eventName) {
+    case "pull_request": {
+      const event = normalizePullRequestEvent(args.deliveryId, args.body);
+      return event ? [event] : [];
+    }
+    case "pull_request_review": {
+      const event = normalizePullRequestReviewEvent(args.deliveryId, args.body);
+      return event ? [event] : [];
+    }
+    case "issue_comment": {
+      const event = normalizeIssueCommentEvent(args.deliveryId, args.body);
+      return event ? [event] : [];
+    }
+    case "pull_request_review_comment": {
+      const event = normalizePullRequestReviewCommentEvent(
+        args.deliveryId,
+        args.body
+      );
+      return event ? [event] : [];
+    }
+    case "check_suite":
+      return normalizeCheckSuiteEvents(args.deliveryId, args.body);
+    default:
+      return [];
+  }
+}
+
+export {
+  gitHubPullRequestSubscribable,
+  normalizeGitHubResourceEvents
+};

package/dist/db/schema.d.ts

@@ -0,0 +1,334 @@
+import { z } from "zod";
+export declare const githubPullRequestStateSchema: z.ZodEnum<{
+    merged: "merged";
+    open: "open";
+    closed_unmerged: "closed_unmerged";
+}>;
+export type GitHubPullRequestState = z.output<typeof githubPullRequestStateSchema>;
+/** Current provider projection for pull requests classified as Junior-owned. */
+export declare const juniorGitHubPullRequests: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "junior_github_pull_requests";
+    schema: undefined;
+    columns: {
+        pullRequestId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pull_request_id";
+            tableName: "junior_github_pull_requests";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        repositoryId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "repository_id";
+            tableName: "junior_github_pull_requests";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        repositoryFullName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "repository_full_name";
+            tableName: "junior_github_pull_requests";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        number: import("drizzle-orm/pg-core").PgColumn<{
+            name: "number";
+            tableName: "junior_github_pull_requests";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        state: import("drizzle-orm/pg-core").PgColumn<{
+            name: "state";
+            tableName: "junior_github_pull_requests";
+            dataType: "string";
+            columnType: "PgText";
+            data: "merged" | "open" | "closed_unmerged";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: "merged" | "open" | "closed_unmerged";
+        }>;
+        openedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "opened_at";
+            tableName: "junior_github_pull_requests";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        mergedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "merged_at";
+            tableName: "junior_github_pull_requests";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        closedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "closed_at";
+            tableName: "junior_github_pull_requests";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "junior_github_pull_requests";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const githubSqlSchema: {
+    juniorGitHubPullRequests: import("drizzle-orm/pg-core").PgTableWithColumns<{
+        name: "junior_github_pull_requests";
+        schema: undefined;
+        columns: {
+            pullRequestId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "pull_request_id";
+                tableName: "junior_github_pull_requests";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            repositoryId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "repository_id";
+                tableName: "junior_github_pull_requests";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            repositoryFullName: import("drizzle-orm/pg-core").PgColumn<{
+                name: "repository_full_name";
+                tableName: "junior_github_pull_requests";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            number: import("drizzle-orm/pg-core").PgColumn<{
+                name: "number";
+                tableName: "junior_github_pull_requests";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            state: import("drizzle-orm/pg-core").PgColumn<{
+                name: "state";
+                tableName: "junior_github_pull_requests";
+                dataType: "string";
+                columnType: "PgText";
+                data: "merged" | "open" | "closed_unmerged";
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: "merged" | "open" | "closed_unmerged";
+            }>;
+            openedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "opened_at";
+                tableName: "junior_github_pull_requests";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            mergedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "merged_at";
+                tableName: "junior_github_pull_requests";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            closedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "closed_at";
+                tableName: "junior_github_pull_requests";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "updated_at";
+                tableName: "junior_github_pull_requests";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "pg";
+    }>;
+};