@finalai/final-agent-provider 0.6.2 → 0.7.0

package/dist/modules/channels/github.mjs

@@ -0,0 +1,720 @@
+import {
+  defineChannel,
+  packageRef,
+  jsonValueSchema
+} from "@finalai/agent-provider";
+import * as z from "zod";
+import {
+  deletedMirrorReceiptSchema,
+  mirrorReceiptKey,
+  settleMirrorReaction,
+  shareReplyReceipt
+} from "./reply-receipts.mjs";
+import {
+  channelBaseUrl,
+  providerPlaceKey,
+  confirmOAuth,
+  deliveryRetention,
+  externalKey,
+  inTenant,
+  parseJson,
+  personFor,
+  receivePersonMessage,
+  refString,
+  responseJson,
+  startOAuth,
+  stateKey,
+  takeOAuth,
+  textOf,
+  completionText,
+  verifyHmac
+} from "./channel-utils.mjs";
+const configSchema = z.object({
+  baseUrl: z.string().url().optional(),
+  mention: z.string().default("final")
+});
+const missingTarget = /* @__PURE__ */ Symbol("missing GitHub target");
+const api = async (ctx, path, body, method) => {
+  const app = await ctx.credentials.app({
+    tenant: refString(ctx.origin?.ref, "tenant") ?? ctx.origin?.place.tenant
+  });
+  const response = await ctx.credentials.fetch(`https://api.github.com${path}`, {
+    method: method ?? (body == null ? "GET" : "POST"),
+    headers: {
+      authorization: `Bearer ${app.accessToken}`,
+      accept: "application/vnd.github+json",
+      "x-github-api-version": "2022-11-28",
+      "content-type": "application/json"
+    },
+    ...body == null ? {} : { body: JSON.stringify(body) }
+  });
+  if (response.status === 404 && path.includes("/collaborators/")) return { permission: "none" };
+  if (response.status === 404 && method === "DELETE") {
+    await response.text();
+    return missingTarget;
+  }
+  if (response.status === 403) {
+    const text = await response.text();
+    throw new Error(`Channel request failed (403): ${text.slice(0, 500)}`, {
+      cause: {
+        status: 403,
+        rateLimited: response.headers.get("x-ratelimit-remaining") === "0" || response.headers.has("retry-after") || /rate limit/i.test(text)
+      }
+    });
+  }
+  return responseJson(response);
+};
+const classifyMirrorReaction = async (args) => {
+  const failure = (cause) => z.object({ status: z.number(), rateLimited: z.boolean().optional() }).safeParse(cause instanceof Error ? cause.cause : null);
+  const error = failure(args.cause);
+  if (!error.success) return "retry";
+  if (error.data.status === 403) return error.data.rateLimited === false ? "unavailable" : "retry";
+  if (error.data.status !== 404) return "retry";
+  try {
+    await api(args.ctx, `/repos/${args.repo}`);
+  } catch (cause) {
+    const denied = failure(cause);
+    return denied.success && (denied.data.status === 404 || denied.data.status === 403 && denied.data.rateLimited === false) ? "unavailable" : "retry";
+  }
+  try {
+    await api(
+      args.ctx,
+      `/repos/${args.repo}/${args.ctx.origin.place.kind === "review-thread" ? "pulls" : "issues"}/comments/${args.target}`
+    );
+    return "unavailable";
+  } catch (cause) {
+    const missing = failure(cause);
+    return missing.success && missing.data.status === 404 ? "missing" : missing.success && missing.data.status === 403 && missing.data.rateLimited === false ? "unavailable" : "retry";
+  }
+};
+const commentText = (body) => body.length > 6e4 ? `${body.slice(0, 59500)}
+
+Continue in Final \u2192` : body;
+const commentSchema = z.object({
+  action: z.string(),
+  sender: z.object({ id: z.number(), login: z.string(), type: z.string().optional() }),
+  repository: z.object({
+    full_name: z.string(),
+    owner: z.object({ login: z.string() }),
+    name: z.string()
+  }),
+  comment: z.object({
+    id: z.number(),
+    body: z.string(),
+    html_url: z.string(),
+    user: z.object({ id: z.number(), login: z.string() }),
+    in_reply_to_id: z.number().optional()
+  }),
+  issue: z.object({
+    number: z.number(),
+    title: z.string(),
+    pull_request: z.object({ url: z.string() }).optional()
+  }).optional(),
+  pull_request: z.object({ number: z.number(), title: z.string() }).optional()
+});
+const visibleMentionText = (text) => {
+  let fence = null;
+  const visible = [];
+  for (const line of text.replace(/<!--[\s\S]*?(?:-->|$)/g, "").split("\n")) {
+    const marker = /^\s{0,3}(`{3,}|~{3,})/.exec(line)?.[1];
+    if (marker != null) {
+      if (fence == null) fence = { marker: marker[0] ?? "`", length: marker.length };
+      else if (marker[0] === fence.marker && marker.length >= fence.length) fence = null;
+      continue;
+    }
+    if (fence != null || /^\s*>|^(?: {4}|\t)/.test(line)) continue;
+    visible.push(line.replace(/(`+).*?\1/g, ""));
+  }
+  return visible.join("\n");
+};
+const reactionReceiptSchema = z.object({
+  id: z.number(),
+  principals: z.array(z.string()),
+  overflow: z.boolean(),
+  owned: z.boolean().default(false)
+});
+const replyKey = (ctx, replyOf) => stateKey(
+  "github-reply",
+  replyOf?.externalKey ?? refString(ctx.origin.ref, "externalKey") ?? ctx.origin.place.id,
+  replyOf?.turnId ?? ctx.turn.id
+);
+const comment = async (ctx, body, key = replyKey(ctx)) => {
+  const resource = ctx.origin.place.kind === "review-thread" ? ctx.origin.place.parent : ctx.origin.place;
+  const repo = refString(ctx.origin.ref, "repository") ?? resource?.id.split("#")[0];
+  const issue = refString(ctx.origin.ref, "number") ?? resource?.id.split("#")[1];
+  if (repo == null || issue == null || body.length === 0) return;
+  const receipt = await ctx.store.get(key);
+  if (deletedMirrorReceiptSchema.safeParse(receipt).success) return;
+  const saved = z.object({ id: z.number() }).safeParse(receipt);
+  if (saved.success) return;
+  const result = z.object({ id: z.number() }).parse(
+    await api(
+      ctx,
+      ctx.origin.place.kind === "review-thread" ? `/repos/${repo}/pulls/${issue}/comments/${refString(ctx.origin.ref, "commentId") ?? ctx.origin.place.id.split(":").at(-1)}/replies` : `/repos/${repo}/issues/${issue}/comments`,
+      {
+        body: commentText(body)
+      }
+    )
+  );
+  await ctx.store.set(key, { id: result.id }, deliveryRetention);
+};
+const githubReaction = (emoji) => {
+  const reactions = {
+    "\u{1F44D}": "+1",
+    "\u{1F44E}": "-1",
+    "\u{1F604}": "laugh",
+    "\u{1F389}": "hooray",
+    "\u{1F615}": "confused",
+    "\u2764\uFE0F": "heart",
+    "\u2764": "heart",
+    "\u{1F680}": "rocket",
+    "\u{1F440}": "eyes"
+  };
+  return reactions[emoji] ?? (["+1", "-1", "laugh", "hooray", "confused", "heart", "rocket", "eyes"].includes(emoji) ? emoji : null);
+};
+const reactionTarget = async (ctx, data) => {
+  if (data.replyOf != null) {
+    const saved = z.object({ id: z.number() }).safeParse(await ctx.store.get(replyKey(ctx, data.replyOf)));
+    return saved.success ? saved.data.id : null;
+  }
+  if (data.externalKey.startsWith("final:")) {
+    const key2 = mirrorReceiptKey({
+      provider: "github",
+      place: ctx.origin.place,
+      externalKey: data.externalKey
+    });
+    if (key2 == null) return null;
+    const saved = z.object({ id: z.number() }).safeParse(await ctx.store.get(key2));
+    return saved.success ? saved.data.id : null;
+  }
+  const key = z.tuple([z.string().nullable(), z.string(), z.string()]).safeParse(parseJson(data.externalKey));
+  if (!key.success || !/^\d+$/.test(key.data[2])) return null;
+  return Number(key.data[2]);
+};
+const githubChannel = (options = {}) => {
+  const config = configSchema.parse(options);
+  return defineChannel({
+    name: "github",
+    config,
+    installed: packageRef("@finalai/final-agent-provider/channels/github"),
+    credentials: { app: "github" },
+    identity: {
+      kind: "redirect",
+      start: async (args, ctx) => {
+        const app = await ctx.credentials.appInfo();
+        return startOAuth(
+          {
+            ...args,
+            authorizeUrl: "https://github.com/login/oauth/authorize",
+            clientId: app.clientId,
+            redirectUri: `${channelBaseUrl(config)}/b/${ctx.binding.id}/oauth/callback`,
+            scope: "read:user"
+          },
+          ctx
+        );
+      }
+    },
+    places: { kinds: ["pr", "issue", "review-thread"] },
+    routes: [
+      {
+        method: "GET",
+        path: "/oauth/callback",
+        handler: async (ctx) => {
+          const saved = await takeOAuth(ctx.request, ctx);
+          if (saved == null)
+            return new Response("Invalid or expired link request", { status: 400 });
+          const app = await ctx.credentials.appInfo();
+          const token = z.object({ access_token: z.string() }).parse(
+            await responseJson(
+              await ctx.credentials.fetch("https://github.com/login/oauth/access_token", {
+                method: "POST",
+                headers: { accept: "application/json" },
+                body: new URLSearchParams({
+                  client_id: app.clientId,
+                  client_secret: app.clientSecret,
+                  code: saved.code,
+                  redirect_uri: saved.redirectUri
+                })
+              })
+            )
+          );
+          const user = z.object({ id: z.number(), login: z.string() }).parse(
+            await responseJson(
+              await ctx.credentials.fetch("https://api.github.com/user", {
+                headers: {
+                  authorization: `Bearer ${token.access_token}`,
+                  accept: "application/vnd.github+json"
+                }
+              })
+            )
+          );
+          return confirmOAuth(
+            {
+              ticket: saved.ticket,
+              expected: saved.principal,
+              actual: {
+                id: String(user.id),
+                displayName: user.login,
+                ...saved.principal.tenant == null ? {} : { tenant: saved.principal.tenant }
+              }
+            },
+            ctx
+          );
+        }
+      },
+      {
+        method: "POST",
+        path: "/webhook",
+        handler: async (ctx) => {
+          const body = await ctx.request.text();
+          const app = await ctx.credentials.appInfo();
+          const signature = ctx.request.headers.get("x-hub-signature-256");
+          if (app.signingSecret == null || signature == null || !signature.startsWith("sha256=") || !await verifyHmac({ secret: app.signingSecret, body, signature: signature.slice(7) }))
+            return new Response(null, { status: 401 });
+          const event = ctx.request.headers.get("x-github-event");
+          if (event !== "issue_comment" && event !== "pull_request_review_comment" && event !== "pull_request" && event !== "pull_request_review" && event !== "pull_request_review_thread" && event !== "issues" && event !== "installation")
+            return new Response(null, { status: 204 });
+          const result = await ctx.receive({
+            event,
+            body: jsonValueSchema.parse(parseJson(body)),
+            delivery: ctx.request.headers.get("x-github-delivery")
+          });
+          return Response.json(result, { status: 202 });
+        }
+      }
+    ],
+    receive: async (input, baseContext) => {
+      const installation = z.object({ body: z.object({ installation: z.object({ id: z.number() }).optional() }) }).safeParse(input);
+      const ctx = installation.success && installation.data.body.installation != null ? inTenant(baseContext, String(installation.data.body.installation.id)) : baseContext;
+      const wrapped = z.object({ event: z.string(), body: jsonValueSchema }).safeParse(input);
+      if (!wrapped.success) return { ignored: true, reason: "invalid-event" };
+      const lifecycle = z.object({ action: z.string() }).safeParse(wrapped.data.body);
+      const tenant = installation.success && installation.data.body.installation != null ? String(installation.data.body.installation.id) : null;
+      if (wrapped.data.event === "installation" && lifecycle.success && ["deleted", "suspend", "unsuspend"].includes(lifecycle.data.action)) {
+        if (tenant == null) return { ignored: true, reason: "missing-tenant" };
+        const key2 = stateKey("github-suspended", tenant);
+        if (lifecycle.data.action === "deleted") {
+          await ctx.people.revoke({ tenant, reason: "uninstalled" });
+          await ctx.store.set(key2, null);
+        } else await ctx.store.set(key2, lifecycle.data.action === "suspend" ? true : null);
+        return { accepted: true };
+      }
+      if (tenant != null && await ctx.store.get(stateKey("github-suspended", tenant)) === true)
+        return { ignored: true, reason: "installation-suspended" };
+      if (wrapped.data.event !== "issue_comment" && wrapped.data.event !== "pull_request_review_comment") {
+        const resource = z.object({
+          action: z.string(),
+          review: z.object({
+            state: z.string(),
+            body: z.string().nullish(),
+            html_url: z.string().optional(),
+            user: z.object({ login: z.string() }).optional()
+          }).optional(),
+          sender: z.object({ login: z.string() }).optional(),
+          repository: z.object({ full_name: z.string() }),
+          pull_request: z.object({
+            number: z.number(),
+            title: z.string(),
+            state: z.string().optional(),
+            html_url: z.string().optional()
+          }).optional(),
+          issue: z.object({
+            number: z.number(),
+            title: z.string(),
+            state: z.string().optional(),
+            html_url: z.string().optional()
+          }).optional()
+        }).safeParse(wrapped.data.body);
+        if (!resource.success) return { ignored: true, reason: "unsupported-resource-event" };
+        const item = resource.data.pull_request ?? resource.data.issue;
+        if (item == null) return { ignored: true, reason: "no-resource" };
+        const place2 = {
+          kind: resource.data.pull_request == null ? "issue" : "pr",
+          id: `${resource.data.repository.full_name.toLowerCase()}#${item.number}`,
+          ...installation.success && installation.data.body.installation != null ? { tenant: String(installation.data.body.installation.id) } : {},
+          title: item.title
+        };
+        const observers = await ctx.places.observers(place2);
+        const delivery = z.object({ delivery: z.string().nullable().optional() }).parse(input).delivery;
+        if (delivery == null) return { ignored: true, reason: "missing-delivery-id" };
+        let accepted = false;
+        let refused = null;
+        for (const conversation of observers) {
+          const result2 = await ctx.conversation(conversation).input({
+            label: `GitHub ${place2.kind} ${resource.data.action}`,
+            content: [
+              {
+                type: "text",
+                text: resource.data.review == null ? `${item.title}: ${resource.data.action}${item.state == null ? "" : ` (${item.state})`}${item.html_url == null ? "" : ` ${item.html_url}`}` : `${item.title}: review ${resource.data.action} (${resource.data.review.state})${(resource.data.review.user?.login ?? resource.data.sender?.login) == null ? "" : ` by ${resource.data.review.user?.login ?? resource.data.sender?.login}`}${resource.data.review.html_url == null ? "" : ` ${resource.data.review.html_url}`}${resource.data.review.body == null ? "" : `
+${resource.data.review.body}`}`
+              }
+            ],
+            origin: { place: place2 },
+            idempotencyKey: delivery
+          });
+          if ("refused" in result2) {
+            refused ??= result2;
+            ctx.log("GitHub observer input refused.", { reason: result2.refused });
+          } else accepted = true;
+        }
+        if (!accepted && refused != null) return { accepted: false, refusal: refused };
+        return observers.length === 0 ? { ignored: true, reason: "no-observers" } : { accepted: true };
+      }
+      const parsed = commentSchema.safeParse(wrapped.data.body);
+      if (!parsed.success) return { ignored: true, reason: "not-a-comment" };
+      const event = parsed.data;
+      if (event.sender.type === "Bot") return { ignored: true, reason: "bot" };
+      const target = event.issue ?? event.pull_request;
+      if (target == null) return { ignored: true, reason: "no-issue" };
+      const isPr = event.pull_request != null || event.issue?.pull_request != null;
+      const parent = {
+        kind: isPr ? "pr" : "issue",
+        id: `${event.repository.full_name.toLowerCase()}#${target.number}`,
+        ...installation.success && installation.data.body.installation != null ? { tenant: String(installation.data.body.installation.id) } : {},
+        title: target.title
+      };
+      const place = wrapped.data.event === "pull_request_review_comment" ? {
+        kind: "review-thread",
+        id: `${event.repository.full_name.toLowerCase()}:${event.comment.in_reply_to_id ?? event.comment.id}`,
+        ...parent.tenant == null ? {} : { tenant: parent.tenant },
+        parent,
+        title: target.title
+      } : parent;
+      const principal = {
+        id: String(event.sender.id),
+        displayName: event.sender.login,
+        ...parent.tenant == null ? {} : { tenant: parent.tenant }
+      };
+      const key = externalKey(parent, String(event.comment.id));
+      if (event.action !== "edited" && event.action !== "deleted" && (event.action !== "created" || !new RegExp(
+        `(?:^|[^A-Za-z0-9_@/-])@${config.mention.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?=$|[^A-Za-z0-9_/-])`,
+        "i"
+      ).test(visibleMentionText(event.comment.body))))
+        return { ignored: true, reason: "not-mentioned" };
+      if ((event.action === "edited" || event.action === "deleted") && await ctx.store.get(stateKey("github-origin", key)) == null)
+        return { ignored: true, reason: "unknown-origin" };
+      const permission = z.object({
+        permission: z.string(),
+        user: z.object({
+          permissions: z.object({
+            push: z.boolean().optional(),
+            maintain: z.boolean().optional(),
+            admin: z.boolean().optional()
+          }).optional()
+        }).optional()
+      }).safeParse(
+        await api(
+          ctx,
+          `/repos/${event.repository.full_name.toLowerCase()}/collaborators/${encodeURIComponent(event.sender.login)}/permission`
+        )
+      );
+      if (!permission.success || !["write", "maintain", "admin"].includes(permission.data.permission))
+        return { ignored: true, reason: "not-a-collaborator" };
+      if (event.action === "edited" || event.action === "deleted") {
+        const by = await personFor(ctx, principal);
+        if (typeof by !== "string") return { accepted: false, refusal: by };
+        const route = await ctx.places.resolve(place);
+        if (route.kind !== "connected") return { ignored: true, reason: "unconnected" };
+        const result2 = event.action === "edited" ? await ctx.conversation(route.conversation).edit({
+          externalKey: key,
+          by,
+          content: [{ type: "text", text: event.comment.body }]
+        }) : await ctx.conversation(route.conversation).remove({ externalKey: key, by });
+        return "refused" in result2 ? { accepted: false, refusal: result2 } : { accepted: true };
+      }
+      await api(
+        ctx,
+        `/repos/${event.repository.full_name.toLowerCase()}/${wrapped.data.event === "pull_request_review_comment" ? "pulls" : "issues"}/comments/${event.comment.id}/reactions`,
+        { content: "eyes" }
+      ).catch(() => ctx.log("GitHub acknowledgement unavailable."));
+      const result = await receivePersonMessage({
+        ctx,
+        principal,
+        place,
+        text: event.comment.body,
+        externalKey: key,
+        ref: {
+          externalKey: key,
+          repository: event.repository.full_name.toLowerCase(),
+          number: String(target.number),
+          commentId: String(event.comment.in_reply_to_id ?? event.comment.id),
+          requester: event.sender.login,
+          tenant: installation.success && installation.data.body.installation != null ? String(installation.data.body.installation.id) : null,
+          url: event.comment.html_url
+        }
+      });
+      if ("accepted" in result && !result.accepted) {
+        const noticeKey = stateKey("github-refusal", key);
+        if (await ctx.store.get(noticeKey) == null) {
+          const posted = z.object({ id: z.number() }).parse(
+            await api(
+              ctx,
+              `/repos/${event.repository.full_name.toLowerCase()}/issues/${target.number}/comments`,
+              {
+                body: `@${event.sender.login} ${result.refusal.message} ${result.refusal.linkUrl ?? result.refusal.connectUrl ?? ""}`
+              }
+            )
+          );
+          await ctx.store.set(noticeKey, posted.id, deliveryRetention);
+        }
+      }
+      if ("accepted" in result && result.accepted)
+        await ctx.store.set(stateKey("github-origin", key), true, deliveryRetention);
+      return result;
+    },
+    events: {
+      "message.posted": async (data, ctx) => {
+        await comment(
+          ctx,
+          `From ${data.author.displayName} in Final
+
+${textOf(data.message.content)}`,
+          stateKey("github-mirror", providerPlaceKey(ctx.origin.place), data.message.id)
+        );
+      },
+      "turn.completed": async (data, ctx) => {
+        const resource = ctx.origin.place.kind === "review-thread" ? ctx.origin.place.parent : ctx.origin.place;
+        const repo = refString(ctx.origin.ref, "repository") ?? resource?.id.split("#")[0];
+        const issue = refString(ctx.origin.ref, "number") ?? resource?.id.split("#")[1];
+        const thread = ctx.origin.place.kind === "review-thread" ? refString(ctx.origin.ref, "commentId") ?? ctx.origin.place.id.split(":").at(-1) : null;
+        await shareReplyReceipt({
+          bindingId: ctx.binding.id,
+          store: ctx.store,
+          destination: stateKey(
+            "github",
+            ctx.origin.place.tenant ?? null,
+            repo?.toLowerCase() ?? null,
+            issue ?? null,
+            thread ?? null
+          ),
+          messageIds: data.messages?.map((message) => message.id) ?? [],
+          originKey: replyKey(ctx),
+          send: (key) => comment(ctx, completionText(data), key)
+        });
+      },
+      "decision.created": async (data, ctx) => {
+        await comment(
+          ctx,
+          `Waiting on @${refString(ctx.origin.ref, "requester") ?? "the requester"} in Final.`,
+          stateKey("github-decision", providerPlaceKey(ctx.origin.place), data.decisionId)
+        );
+      },
+      "decision.resolved": async (data, ctx) => {
+        const repo = refString(ctx.origin.ref, "repository");
+        const saved = z.object({ id: z.number() }).safeParse(
+          await ctx.store.get(
+            stateKey("github-decision", providerPlaceKey(ctx.origin.place), data.decisionId)
+          )
+        );
+        if (repo != null && saved.success)
+          await api(
+            ctx,
+            `/repos/${repo}/${ctx.origin.place.kind === "review-thread" ? "pulls" : "issues"}/comments/${saved.data.id}`,
+            { body: "Decision answered in Final." },
+            "PATCH"
+          );
+      },
+      "message.edited": async (data, ctx) => {
+        if (data.replyOf == null && data.externalKey.startsWith("final:")) {
+          const key = mirrorReceiptKey({
+            provider: "github",
+            place: ctx.origin.place,
+            externalKey: data.externalKey,
+            messageId: data.message.id
+          });
+          if (key == null) return;
+          const saved2 = z.object({ id: z.number() }).safeParse(await ctx.store.get(key));
+          const resource = ctx.origin.place.kind === "review-thread" ? ctx.origin.place.parent : ctx.origin.place;
+          const repo2 = refString(ctx.origin.ref, "repository") ?? resource?.id.split("#")[0];
+          if (!saved2.success || repo2 == null) return;
+          try {
+            await api(
+              ctx,
+              `/repos/${repo2}/${ctx.origin.place.kind === "review-thread" ? "pulls" : "issues"}/comments/${saved2.data.id}`,
+              {
+                body: commentText(
+                  `From ${data.author.displayName} in Final
+
+${textOf(data.message.content)}`
+                )
+              },
+              "PATCH"
+            );
+          } catch (cause) {
+            if (!(cause instanceof Error) || !z.object({ status: z.literal(404) }).safeParse(cause.cause).success)
+              throw cause;
+            await api(ctx, `/repos/${repo2}`);
+            await ctx.store.set(key, { deleted: true }, deliveryRetention);
+          }
+          return;
+        }
+        if (data.replyOf == null) return;
+        const repo = refString(ctx.origin.ref, "repository");
+        const saved = z.object({ id: z.number() }).safeParse(await ctx.store.get(replyKey(ctx, data.replyOf)));
+        if (repo != null && saved.success)
+          await api(
+            ctx,
+            `/repos/${repo}/${ctx.origin.place.kind === "review-thread" ? "pulls" : "issues"}/comments/${saved.data.id}`,
+            { body: textOf(data.message.content).slice(0, 6e4) },
+            "PATCH"
+          );
+      },
+      "message.removed": async (data, ctx) => {
+        if (data.replyOf == null && data.externalKey.startsWith("final:")) {
+          const key = mirrorReceiptKey({
+            provider: "github",
+            place: ctx.origin.place,
+            externalKey: data.externalKey,
+            messageId: data.message.id
+          });
+          if (key == null) return;
+          const saved2 = z.object({ id: z.number() }).safeParse(await ctx.store.get(key));
+          const resource = ctx.origin.place.kind === "review-thread" ? ctx.origin.place.parent : ctx.origin.place;
+          const repo2 = refString(ctx.origin.ref, "repository") ?? resource?.id.split("#")[0];
+          if (!saved2.success || repo2 == null) return;
+          const result = await api(
+            ctx,
+            `/repos/${repo2}/${ctx.origin.place.kind === "review-thread" ? "pulls" : "issues"}/comments/${saved2.data.id}`,
+            void 0,
+            "DELETE"
+          );
+          if (result === missingTarget) await api(ctx, `/repos/${repo2}`);
+          await ctx.store.set(key, { deleted: true }, deliveryRetention);
+          return;
+        }
+        if (data.replyOf == null) return;
+        const repo = refString(ctx.origin.ref, "repository");
+        const saved = z.object({ id: z.number() }).safeParse(await ctx.store.get(replyKey(ctx, data.replyOf)));
+        if (repo != null && saved.success)
+          await api(
+            ctx,
+            `/repos/${repo}/${ctx.origin.place.kind === "review-thread" ? "pulls" : "issues"}/comments/${saved.data.id}`,
+            void 0,
+            "DELETE"
+          );
+      },
+      "reaction.added": async (data, ctx) => {
+        const resource = ctx.origin.place.kind === "review-thread" ? ctx.origin.place.parent : ctx.origin.place;
+        const repo = refString(ctx.origin.ref, "repository") ?? (data.replyOf == null && data.externalKey.startsWith("final:") ? resource?.id.split("#")[0] : null);
+        const target = await reactionTarget(ctx, data);
+        const content = githubReaction(data.emoji);
+        if (repo == null || target == null || content == null) return;
+        const mirrorKey = data.replyOf == null ? mirrorReceiptKey({
+          provider: "github",
+          place: ctx.origin.place,
+          externalKey: data.externalKey
+        }) : null;
+        await settleMirrorReaction({
+          ctx,
+          key: mirrorKey,
+          classify: (cause) => classifyMirrorReaction({ ctx, repo, target, cause }),
+          work: async () => {
+            const key = stateKey(
+              "github-reaction",
+              repo,
+              ctx.origin.place.kind === "review-thread" ? "review-comment" : "issue-comment",
+              String(target),
+              content
+            );
+            const principal = JSON.stringify([data.principal.tenant ?? null, data.principal.id]);
+            const saved = reactionReceiptSchema.safeParse(await ctx.store.get(key));
+            if (saved.success) {
+              if (saved.data.principals.includes(principal) || saved.data.overflow) return;
+              await ctx.store.set(
+                key,
+                saved.data.principals.length >= 256 ? { ...saved.data, overflow: true } : { ...saved.data, principals: [...saved.data.principals, principal] },
+                deliveryRetention
+              );
+              return;
+            }
+            let owned = false;
+            const reactionContext = {
+              ...ctx,
+              credentials: {
+                ...ctx.credentials,
+                fetch: async (request, init) => {
+                  const response = await ctx.credentials.fetch(request, init);
+                  owned = response.status === 201;
+                  return response;
+                }
+              }
+            };
+            const result = z.object({ id: z.number() }).parse(
+              await api(
+                reactionContext,
+                `/repos/${repo}/${ctx.origin.place.kind === "review-thread" ? "pulls" : "issues"}/comments/${target}/reactions`,
+                { content }
+              )
+            );
+            await ctx.store.set(
+              key,
+              { id: result.id, principals: [principal], overflow: false, owned },
+              deliveryRetention
+            );
+          }
+        });
+      },
+      "reaction.removed": async (data, ctx) => {
+        const resource = ctx.origin.place.kind === "review-thread" ? ctx.origin.place.parent : ctx.origin.place;
+        const repo = refString(ctx.origin.ref, "repository") ?? (data.replyOf == null && data.externalKey.startsWith("final:") ? resource?.id.split("#")[0] : null);
+        const target = await reactionTarget(ctx, data);
+        const content = githubReaction(data.emoji);
+        if (repo == null || target == null || content == null) return;
+        const mirrorKey = data.replyOf == null ? mirrorReceiptKey({
+          provider: "github",
+          place: ctx.origin.place,
+          externalKey: data.externalKey
+        }) : null;
+        await settleMirrorReaction({
+          ctx,
+          key: mirrorKey,
+          classify: (cause) => classifyMirrorReaction({ ctx, repo, target, cause }),
+          work: async () => {
+            const key = stateKey(
+              "github-reaction",
+              repo,
+              ctx.origin.place.kind === "review-thread" ? "review-comment" : "issue-comment",
+              String(target),
+              content
+            );
+            const saved = reactionReceiptSchema.safeParse(await ctx.store.get(key));
+            if (!saved.success || saved.data.overflow) return;
+            const principal = JSON.stringify([data.principal.tenant ?? null, data.principal.id]);
+            if (!saved.data.principals.includes(principal)) return;
+            const remaining = saved.data.principals.filter((value) => value !== principal);
+            if (remaining.length > 0) {
+              await ctx.store.set(key, { ...saved.data, principals: remaining }, deliveryRetention);
+              return;
+            }
+            if (saved.data.owned) {
+              const result = await api(
+                ctx,
+                `/repos/${repo}/${ctx.origin.place.kind === "review-thread" ? "pulls" : "issues"}/comments/${target}/reactions/${saved.data.id}`,
+                void 0,
+                "DELETE"
+              );
+              if (mirrorKey != null && result === missingTarget) {
+                await api(ctx, `/repos/${repo}`);
+                try {
+                  await api(
+                    ctx,
+                    `/repos/${repo}/${ctx.origin.place.kind === "review-thread" ? "pulls" : "issues"}/comments/${target}`
+                  );
+                } catch (cause) {
+                  if (!(cause instanceof Error) || !z.object({ status: z.literal(404) }).safeParse(cause.cause).success)
+                    throw cause;
+                  await ctx.store.set(mirrorKey, { deleted: true }, deliveryRetention);
+                }
+              }
+            }
+            await ctx.store.set(key, null);
+          }
+        });
+      }
+    }
+  });
+};
+export {
+  githubChannel
+};
+//# sourceMappingURL=github.mjs.map