@desplega.ai/agent-swarm 2.4.4 → 2.5.0

package/src/bitbucket/handlers.ts

@@ -0,0 +1,434 @@
+/**
+ * Bitbucket Cloud webhook event handlers.
+ *
+ * Mirrors src/azure-devops/handlers.ts and src/gitlab/handlers.ts:
+ * - Parses webhook payloads (pull request created / commented / merged / declined)
+ * - Creates agent tasks via createTaskWithSiblingAwareness()
+ * - Deduplicates deliveries (X-Request-UUID) and events via in-memory TTL maps
+ * - Detects bot mentions and reviewer requests
+ */
+
+import {
+  failTask,
+  findActiveTasksByVcs,
+  findTaskByVcs,
+  getAllAgents,
+  incrKv,
+  upsertKv,
+} from "../be/db";
+import { renderIdentity, resolveIdentity } from "../be/identity";
+import { findUserByExternalId } from "../be/users";
+import { resolveTemplate } from "../prompts/resolver";
+import { bitbucketContextKey } from "../tasks/context-key";
+import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
+import { resolveBitbucketBotAccountId } from "./api";
+import { getBitbucketBotName } from "./auth";
+// Side-effect import: registers all Bitbucket event templates in the in-memory registry
+import "./templates";
+import type {
+  BitbucketAccount,
+  BitbucketPullRequest,
+  PullRequestCommentEvent,
+  PullRequestEvent,
+} from "./types";
+
+type HandlerResult = { created: boolean; taskId?: string };
+
+// ── Dedup caches (same pattern as GitHub/GitLab) ──
+const DEDUP_TTL_MS = 60_000;
+const processedEvents = new Map<string, number>();
+const processedDeliveries = new Map<string, number>();
+
+function sweep(cache: Map<string, number>, now: number): void {
+  for (const [k, ts] of cache) {
+    if (now - ts > DEDUP_TTL_MS) cache.delete(k);
+  }
+}
+
+/** Content-key dedup: true when the same event was handled in the last 60s. */
+export function isDuplicate(key: string): boolean {
+  const now = Date.now();
+  sweep(processedEvents, now);
+  if (processedEvents.has(key)) return true;
+  processedEvents.set(key, now);
+  return false;
+}
+
+/**
+ * Hold the content-key reservation for `key` while `fn` runs. A throw releases
+ * it, so Bitbucket's retry of a delivery that failed with a 5xx is not taken
+ * for a duplicate. Returns null when the key is already held.
+ */
+async function withDedupReservation(
+  key: string,
+  fn: () => Promise<HandlerResult>,
+): Promise<HandlerResult | null> {
+  if (isDuplicate(key)) return null;
+  try {
+    return await fn();
+  } catch (err) {
+    processedEvents.delete(key);
+    throw err;
+  }
+}
+
+/**
+ * Delivery dedup on `X-Request-UUID`. Bitbucket retries a delivery (same
+ * UUID) when it gets a 5xx or times out, so only a delivery that was acked
+ * is recorded — see `markDeliveryProcessed`.
+ */
+export function isDuplicateDelivery(requestUuid: string | undefined): boolean {
+  if (!requestUuid) return false;
+  sweep(processedDeliveries, Date.now());
+  return processedDeliveries.has(requestUuid);
+}
+
+export function markDeliveryProcessed(requestUuid: string | undefined): void {
+  if (requestUuid) processedDeliveries.set(requestUuid, Date.now());
+}
+
+/** Reset dedup state (tests). */
+export function resetBitbucketDedup(): void {
+  processedEvents.clear();
+  processedDeliveries.clear();
+}
+
+// ── Helpers ──
+
+export function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Mention patterns: the mention picker stores `@{<account_id>}` in the
+ * comment's raw content; a typed mention stays plain `@name`.
+ */
+function mentionPatterns(botAccountId: string | null): RegExp[] {
+  // `(?![\w-])` rather than `\b`, so `@agent-swarm-bot-two` is not the bot.
+  const patterns = [new RegExp(`@${escapeRegExp(getBitbucketBotName())}(?![\\w-])`, "gi")];
+  if (botAccountId) patterns.push(new RegExp(`@\\{${escapeRegExp(botAccountId)}\\}`, "gi"));
+  return patterns;
+}
+
+export function detectMention(
+  text: string | null | undefined,
+  botAccountId: string | null,
+): boolean {
+  if (!text) return false;
+  return mentionPatterns(botAccountId).some((re) => {
+    re.lastIndex = 0;
+    return re.test(text);
+  });
+}
+
+function extractMentionContext(text: string, botAccountId: string | null): string {
+  return mentionPatterns(botAccountId)
+    .reduce((acc, re) => acc.replace(re, ""), text)
+    .trim();
+}
+
+function isBot(account: BitbucketAccount | undefined, botAccountId: string | null): boolean {
+  return !!botAccountId && account?.account_id === botAccountId;
+}
+
+function pullRequestWebUrl(repo: string, pr: BitbucketPullRequest): string {
+  return pr.links?.html?.href ?? `https://bitbucket.org/${repo}/pull-requests/${pr.id}`;
+}
+
+function contextKeyOf(event: PullRequestEvent): string {
+  return bitbucketContextKey({
+    repoUuid: event.repository.uuid,
+    pullRequestId: event.pullrequest.id,
+  });
+}
+
+// ── Payload shape ──
+
+/** The pull request event, or null when the payload lacks the fields we read. */
+export function pullRequestEventOf(body: unknown): PullRequestEvent | null {
+  const event = body as Partial<PullRequestEvent> | null | undefined;
+  const pr = event?.pullrequest;
+  const repo = event?.repository;
+  if (
+    typeof pr?.id !== "number" ||
+    typeof pr.title !== "string" ||
+    typeof repo?.uuid !== "string" ||
+    typeof repo.full_name !== "string" ||
+    !event?.actor
+  ) {
+    return null;
+  }
+  return event as PullRequestEvent;
+}
+
+/** The comment event, or null when the pull request or comment is missing. */
+export function pullRequestCommentEventOf(body: unknown): PullRequestCommentEvent | null {
+  const event = pullRequestEventOf(body) as PullRequestCommentEvent | null;
+  const comment = event?.comment;
+  if (!event || typeof comment?.id !== "number" || typeof comment.content?.raw !== "string") {
+    return null;
+  }
+  return event;
+}
+
+function warnMalformed(eventKey: string) {
+  console.warn(`[Bitbucket] Ignoring ${eventKey} event: required payload fields are missing`);
+}
+
+export async function findLeadAgent() {
+  const agents = await getAllAgents();
+  return (
+    agents.find((a) => a.role === "lead" && a.status === "idle") ??
+    agents.find((a) => a.role === "lead") ??
+    null
+  );
+}
+
+// ── Identity resolution ──
+
+const UNMAPPED_NAMESPACE = "integration:unmapped:bitbucket";
+const UNMAPPED_TTL_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+
+function externalIdOf(account: BitbucketAccount | undefined): string | null {
+  return account?.account_id?.trim() || account?.uuid?.trim() || null;
+}
+
+/**
+ * Resolve a Bitbucket account to a `users.id` via its linked `bitbucket`
+ * identity (Atlassian `account_id`). Webhook payloads carry no email, so an
+ * unknown sender is recorded as an unmapped tracker entry for operator triage.
+ */
+export async function resolveBitbucketSender(
+  account: BitbucketAccount | undefined,
+  sampleEventType: string,
+  sampleContext: string,
+): Promise<string | undefined> {
+  const externalId = externalIdOf(account);
+  if (!externalId) return undefined;
+  const existing = await findUserByExternalId("bitbucket", externalId);
+  if (existing) return existing.id;
+
+  await upsertKv({
+    namespace: UNMAPPED_NAMESPACE,
+    key: `${externalId}:meta`,
+    value: {
+      lastSeenAt: new Date().toISOString(),
+      displayName: account?.display_name,
+      sampleEventType,
+      sampleContext: sampleContext.slice(0, 100),
+    },
+    valueType: "json",
+    expiresAt: Date.now() + UNMAPPED_TTL_MS,
+  });
+  await incrKv(UNMAPPED_NAMESPACE, `${externalId}:count`, 1);
+  return undefined;
+}
+
+/**
+ * Render a Bitbucket account for agent-visible text: the resolved canonical
+ * name or the explicit UNKNOWN sentinel.
+ */
+export async function renderBitbucketIdentity(
+  account: BitbucketAccount | undefined,
+): Promise<string> {
+  return renderIdentity(await resolveIdentity("bitbucket", externalIdOf(account) ?? ""));
+}
+
+async function createBitbucketTask(
+  text: string,
+  event: PullRequestEvent,
+  fields: {
+    taskType: "bitbucket-pr" | "bitbucket-comment";
+    vcsEventType: string;
+    author: BitbucketAccount | undefined;
+    requestedByUserId: string | undefined;
+    vcsCommentId?: number;
+    parentTaskId?: string;
+  },
+): Promise<HandlerResult> {
+  const { pullrequest: pr, repository } = event;
+  const lead = await findLeadAgent();
+  const task = await createTaskWithSiblingAwareness(
+    text,
+    {
+      agentId: lead?.id ?? null,
+      routingReason: lead ? "skill" : undefined,
+      routingSource: lead ? "engine_default" : undefined,
+      source: "bitbucket",
+      vcsProvider: "bitbucket",
+      taskType: fields.taskType,
+      vcsRepo: repository.full_name,
+      vcsEventType: fields.vcsEventType,
+      vcsNumber: pr.id,
+      vcsCommentId: fields.vcsCommentId,
+      vcsAuthor: externalIdOf(fields.author) ?? undefined,
+      requestedByUserId: fields.requestedByUserId,
+      vcsUrl: pullRequestWebUrl(repository.full_name, pr),
+      parentTaskId: fields.parentTaskId,
+      contextKey: contextKeyOf(event),
+    },
+    { origin: "webhook" },
+  );
+  return { created: true, taskId: task.id };
+}
+
+// ── Event Handlers ──
+
+/**
+ * `pullrequest:created`: a bot mention in the description, or the bot listed
+ * as a reviewer, creates one task.
+ */
+export async function handlePullRequestCreated(body: unknown): Promise<HandlerResult> {
+  const event = pullRequestEventOf(body);
+  if (!event) {
+    warnMalformed("pullrequest:created");
+    return { created: false };
+  }
+  const { pullrequest: pr, repository } = event;
+  const repo = repository.full_name;
+  const author = pr.author ?? event.actor;
+  console.log(`[Bitbucket] PR #${pr.id} created by ${author.display_name} in ${repo}`);
+
+  const botAccountId = await resolveBitbucketBotAccountId();
+  if (isBot(author, botAccountId)) {
+    console.log(`[Bitbucket] PR opened by the bot itself, skipping`);
+    return { created: false };
+  }
+
+  const mentioned = detectMention(pr.description, botAccountId);
+  const reviewRequested =
+    !!botAccountId && (pr.reviewers ?? []).some((r) => r.account_id === botAccountId);
+  if (!mentioned && !reviewRequested) {
+    console.log(`[Bitbucket] PR opened without bot mention or review request, skipping`);
+    return { created: false };
+  }
+
+  const dedupKey = `bitbucket-pr-${repository.uuid}-${pr.id}-created`;
+  const outcome = await withDedupReservation(dedupKey, async () => {
+    const requestedByUserId = await resolveBitbucketSender(
+      author,
+      "pull_request",
+      `PR #${pr.id}: ${pr.title}`,
+    );
+
+    const context = pr.description ? extractMentionContext(pr.description, botAccountId) : "";
+    // A mention is the explicit ask; the reviewer template is for a bare review request.
+    const templateId = mentioned
+      ? "bitbucket.pull_request.opened"
+      : "bitbucket.pull_request.review_requested";
+    const result = resolveTemplate(templateId, {
+      pr_id: pr.id,
+      pr_title: pr.title,
+      repo,
+      username: await renderBitbucketIdentity(author),
+      source_branch: pr.source?.branch?.name ?? "",
+      target_branch: pr.destination?.branch?.name ?? "",
+      pr_url: pullRequestWebUrl(repo, pr),
+      context_section: context ? `Context: ${context}\n\n` : "",
+    });
+    if (result.skipped) {
+      return { created: false };
+    }
+
+    return createBitbucketTask(result.text, event, {
+      taskType: "bitbucket-pr",
+      vcsEventType: "pull_request",
+      author,
+      requestedByUserId,
+    });
+  });
+  if (!outcome) console.log(`[Bitbucket] Skipping duplicate PR event`);
+  return outcome ?? { created: false };
+}
+
+/**
+ * `pullrequest:comment_created`: a bot mention in a new PR comment (general or
+ * inline) creates a task, linked to any active task for the same PR.
+ */
+export async function handlePullRequestCommentCreated(body: unknown): Promise<HandlerResult> {
+  const event = pullRequestCommentEventOf(body);
+  if (!event) {
+    warnMalformed("pullrequest:comment_created");
+    return { created: false };
+  }
+  const { pullrequest: pr, repository, comment } = event;
+  const repo = repository.full_name;
+  const author = comment.user ?? event.actor;
+
+  const botAccountId = await resolveBitbucketBotAccountId();
+  if (isBot(author, botAccountId)) {
+    return { created: false };
+  }
+  if (!detectMention(comment.content.raw, botAccountId)) {
+    return { created: false };
+  }
+
+  console.log(`[Bitbucket] Comment by ${author.display_name} on PR #${pr.id} in ${repo}`);
+
+  const dedupKey = `bitbucket-comment-${repository.uuid}-${pr.id}-${comment.id}`;
+  const outcome = await withDedupReservation(dedupKey, async () => {
+    const requestedByUserId = await resolveBitbucketSender(
+      author,
+      "pull_request_comment",
+      comment.content.raw,
+    );
+
+    const existingTask = await findTaskByVcs(repo, pr.id, "bitbucket");
+    const existingTaskNote = existingTask
+      ? `\n\n_Note: There's an active task (${existingTask.id}) for this PR #${pr.id}._`
+      : "";
+
+    const line = comment.inline?.to ?? comment.inline?.from;
+    const locationSection = comment.inline
+      ? `File: ${comment.inline.path}${line != null ? `:${line}` : ""}\n`
+      : "";
+
+    const result = resolveTemplate("bitbucket.comment.mentioned", {
+      pr_id: pr.id,
+      pr_title: pr.title,
+      username: await renderBitbucketIdentity(author),
+      repo,
+      pr_url: comment.links?.html?.href ?? pullRequestWebUrl(repo, pr),
+      location_section: locationSection,
+      context: extractMentionContext(comment.content.raw, botAccountId),
+      existing_task_note: existingTaskNote,
+    });
+    if (result.skipped) {
+      return { created: false };
+    }
+
+    return createBitbucketTask(result.text, event, {
+      taskType: "bitbucket-comment",
+      vcsEventType: "pull_request_comment",
+      author,
+      requestedByUserId,
+      vcsCommentId: comment.id,
+      parentTaskId: existingTask?.id,
+    });
+  });
+  return outcome ?? { created: false };
+}
+
+/**
+ * `pullrequest:fulfilled` / `pullrequest:rejected`: cancel every active task
+ * for the PR.
+ */
+export async function handlePullRequestClosed(
+  body: unknown,
+  outcome: "merged" | "declined",
+): Promise<HandlerResult> {
+  const event = pullRequestEventOf(body);
+  if (!event) {
+    warnMalformed(outcome === "merged" ? "pullrequest:fulfilled" : "pullrequest:rejected");
+    return { created: false };
+  }
+  const { pullrequest: pr, repository } = event;
+  // Every active task, not only the newest: a comment task is a child of the
+  // PR task, and failTask does not cascade up to the parent.
+  const reason = outcome === "merged" ? "PR was merged" : "PR was declined";
+  for (const task of await findActiveTasksByVcs(repository.full_name, pr.id, "bitbucket")) {
+    console.log(`[Bitbucket] Cancelling task ${task.id} — ${reason}`);
+    await failTask(task.id, reason);
+  }
+  return { created: false };
+}

package/src/bitbucket/index.ts

@@ -0,0 +1,28 @@
+// Bitbucket Cloud Integration
+export {
+  postBitbucketPullRequestComment,
+  resetBitbucketBotCache,
+  resolveBitbucketBotAccountId,
+} from "./api";
+export {
+  getBitbucketBotName,
+  getBitbucketToken,
+  initBitbucket,
+  isBitbucketEnabled,
+  resetBitbucket,
+  verifyBitbucketWebhook,
+} from "./auth";
+export {
+  handlePullRequestClosed,
+  handlePullRequestCommentCreated,
+  handlePullRequestCreated,
+  isDuplicateDelivery,
+  markDeliveryProcessed,
+  pullRequestCommentEventOf,
+  pullRequestEventOf,
+} from "./handlers";
+export type {
+  BitbucketWebhookEvent,
+  PullRequestCommentEvent,
+  PullRequestEvent,
+} from "./types";

package/src/bitbucket/templates.ts

@@ -0,0 +1,134 @@
+/**
+ * Bitbucket Cloud event prompt template definitions.
+ *
+ * Each template is registered at module load time via registerTemplate().
+ * Handlers import this module for the side-effect of registration.
+ *
+ * Template text uses {{variable}} syntax. The resolver interpolates variables
+ * and expands {{@template[id]}} references before returning the final text.
+ */
+
+import { registerTemplate } from "../prompts/registry";
+
+// ============================================================================
+// Common building blocks (Bitbucket-specific)
+// ============================================================================
+
+registerTemplate({
+  eventType: "common.delegation_instruction.bitbucket",
+  header: "",
+  defaultBody:
+    "\n\n**Delegation instruction:** As the lead agent, analyze this and decide whether to handle it yourself or delegate to a worker agent. Use `send-task` to delegate with clear instructions.",
+  variables: [],
+  category: "common",
+});
+
+// There is no Bitbucket CLI in the worker image, so the recipes are curl calls
+// against the REST API with the worker's BITBUCKET_TOKEN.
+registerTemplate({
+  eventType: "common.command_suggestions.bitbucket_pr",
+  header: "",
+  defaultBody:
+    'Workers have `git` authenticated for bitbucket.org and `BITBUCKET_TOKEN` in env; there is no Bitbucket CLI, so use curl against `https://api.bitbucket.org/2.0/repositories/{{repo}}` with `-H "Authorization: Bearer $BITBUCKET_TOKEN"`. Inspect the PR with `GET .../pullrequests/{{pr_id}}` and its diff with `GET .../pullrequests/{{pr_id}}/diff`. Reply with `POST .../pullrequests/{{pr_id}}/comments` and JSON body `{"content":{"raw":"<reply>"}}`. Find a PR by branch with `GET .../pullrequests?q=source.branch.name="<branch>"`. Open a PR with `POST .../pullrequests` and JSON body `{"title":"<title>","source":{"branch":{"name":"<branch>"}},"destination":{"branch":{"name":"<base>"}}}`.',
+  variables: [
+    { name: "repo", description: "Repository full name (<workspace>/<repo_slug>)" },
+    { name: "pr_id", description: "Pull request ID" },
+  ],
+  category: "common",
+});
+
+const SHARED_VARIABLES = [
+  { name: "pr_id", description: "Pull request ID" },
+  { name: "pr_title", description: "Pull request title" },
+  { name: "repo", description: "Repository full name (<workspace>/<repo_slug>)" },
+  { name: "pr_url", description: "Pull request web URL" },
+];
+
+const PR_BRANCH_VARIABLES = [
+  { name: "source_branch", description: "Source branch name" },
+  { name: "target_branch", description: "Target branch name" },
+  { name: "context_section", description: "Context section with description or empty string" },
+];
+
+// ============================================================================
+// Pull request events
+// ============================================================================
+
+registerTemplate({
+  eventType: "bitbucket.pull_request.opened",
+  header: "[Bitbucket PR #{{pr_id}}] {{pr_title}}",
+  defaultBody: `Repo: {{repo}}
+Author: {{username}}
+Branch: {{source_branch}} → {{target_branch}}
+URL: {{pr_url}}
+
+{{context_section}}{{@template[common.command_suggestions.bitbucket_pr]}}{{@template[common.delegation_instruction.bitbucket]}}`,
+  variables: [
+    ...SHARED_VARIABLES,
+    {
+      name: "username",
+      description:
+        "Author identity — resolved canonical name (e.g. 'Luis (bitbucket:557058:…)') or the UNKNOWN sentinel",
+    },
+    ...PR_BRANCH_VARIABLES,
+  ],
+  category: "event",
+});
+
+registerTemplate({
+  eventType: "bitbucket.pull_request.review_requested",
+  header: "[Bitbucket PR #{{pr_id}}] Review requested: {{pr_title}}",
+  defaultBody: `Repo: {{repo}}
+Author: {{username}}
+Branch: {{source_branch}} → {{target_branch}}
+URL: {{pr_url}}
+
+You were added as a reviewer on this pull request.
+
+{{context_section}}{{@template[common.command_suggestions.bitbucket_pr]}}{{@template[common.delegation_instruction.bitbucket]}}`,
+  variables: [
+    ...SHARED_VARIABLES,
+    {
+      name: "username",
+      description:
+        "Author identity — resolved canonical name (e.g. 'Luis (bitbucket:557058:…)') or the UNKNOWN sentinel",
+    },
+    ...PR_BRANCH_VARIABLES,
+  ],
+  category: "event",
+});
+
+// ============================================================================
+// Pull request comment events
+// ============================================================================
+
+registerTemplate({
+  eventType: "bitbucket.comment.mentioned",
+  header: "[Bitbucket Comment on PR #{{pr_id}}] {{username}} mentioned bot",
+  defaultBody: `Repo: {{repo}}
+PR: {{pr_title}}
+URL: {{pr_url}}
+{{location_section}}
+Comment:
+{{context}}{{existing_task_note}}
+
+{{@template[common.command_suggestions.bitbucket_pr]}}{{@template[common.delegation_instruction.bitbucket]}}`,
+  variables: [
+    ...SHARED_VARIABLES,
+    {
+      name: "username",
+      description:
+        "Comment author identity — resolved canonical name (e.g. 'Luis (bitbucket:557058:…)') or the UNKNOWN sentinel",
+    },
+    {
+      name: "location_section",
+      description: "`File: <path>:<line>` line for inline comments, or empty string",
+    },
+    { name: "context", description: "Extracted mention context from comment" },
+    {
+      name: "existing_task_note",
+      description: "Note about existing active task, or empty string",
+    },
+  ],
+  category: "event",
+});

package/src/bitbucket/types.ts

@@ -0,0 +1,65 @@
+/**
+ * Bitbucket Cloud webhook payload types (subsets of the documented event
+ * payloads; only the fields the handlers read).
+ * https://support.atlassian.com/bitbucket-cloud/docs/event-payloads/
+ */
+
+export interface BitbucketAccount {
+  type?: string;
+  /** Atlassian account id, e.g. `557058:<uuid>`. Absent for some app/team actors. */
+  account_id?: string;
+  /** Bitbucket user UUID, wrapped in braces: `{…}`. */
+  uuid?: string;
+  display_name?: string;
+  nickname?: string;
+}
+
+export interface BitbucketRepository {
+  /** Repository UUID, wrapped in braces: `{…}`. Stable across renames. */
+  uuid: string;
+  /** `<workspace>/<repo_slug>` */
+  full_name: string;
+  name?: string;
+  links?: { html?: { href: string } };
+}
+
+export interface BitbucketBranchRef {
+  branch?: { name: string };
+  commit?: { hash: string };
+  repository?: BitbucketRepository;
+}
+
+export interface BitbucketPullRequest {
+  id: number;
+  title: string;
+  description?: string | null;
+  state?: "OPEN" | "MERGED" | "DECLINED" | "SUPERSEDED";
+  author?: BitbucketAccount;
+  source?: BitbucketBranchRef;
+  destination?: BitbucketBranchRef;
+  reviewers?: BitbucketAccount[];
+  links?: { html?: { href: string } };
+}
+
+export interface BitbucketComment {
+  id: number;
+  content: { raw: string; markup?: string; html?: string };
+  user?: BitbucketAccount;
+  inline?: { path: string; from?: number | null; to?: number | null } | null;
+  parent?: { id: number } | null;
+  links?: { html?: { href: string } };
+}
+
+/** `pullrequest:created`, `pullrequest:fulfilled`, `pullrequest:rejected` */
+export interface PullRequestEvent {
+  actor: BitbucketAccount;
+  pullrequest: BitbucketPullRequest;
+  repository: BitbucketRepository;
+}
+
+/** `pullrequest:comment_created` */
+export interface PullRequestCommentEvent extends PullRequestEvent {
+  comment: BitbucketComment;
+}
+
+export type BitbucketWebhookEvent = PullRequestEvent | PullRequestCommentEvent;