@vercel/board 0.0.0 → 0.15.0

package/dist/sync-github.mjs

@@ -0,0 +1,603 @@
+import { c as eventSchema, s as envelope } from "./provider-CuewcDNZ.mjs";
+import { r as withUserTokens, t as connectUserTokens } from "./users-Dls7_ANV.mjs";
+import { r as markdownOf, t as ChatSyncProvider } from "./chat-provider-jFSeyNmB.mjs";
+import { z } from "zod";
+import { connectGitHubAdapter } from "@vercel/connect/chat";
+import { createGitHubAdapter } from "@chat-adapter/github";
+//#region src/sync/github.ts
+/** `owner/repo:12` (and its review threads) → `owner/repo:pulls`; `owner/repo:issue:3` → `owner/repo:issues`. */
+function channelOf(thread) {
+	const match = /^([^:]+):(issue:)?\d+/.exec(thread);
+	return match ? `${match[1]}:${match[2] ? "issues" : "pulls"}` : thread;
+}
+const author = (user) => ({
+	id: `github:user:${user?.id ?? "unknown"}`,
+	handle: user?.login ?? "unknown",
+	name: user?.login ?? "unknown",
+	avatar: user?.avatar_url ?? null,
+	isBot: user?.type === "Bot"
+});
+/** `good first issue` → `good-first-issue`: the part of a label key a name gives. Empty when nothing's left. */
+const slug = (name) => name.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9_.-]+/g, "-").replace(/^[-_.]+|-+$/g, "");
+/**
+* A GitHub label or assignee as a board label: `bug` → `tag.bug=bug`,
+* `julianbenegas` → `assignee.julianbenegas=julianbenegas`. The keys don't
+* name GitHub, so a filter like `--label tag.bug` holds for any platform.
+*/
+function tagOf(prefix, name) {
+	const key = name ? slug(name) : "";
+	return key ? [`${prefix}.${key}`.slice(0, 64), name.slice(0, 256)] : null;
+}
+/** A PR's or issue's current labels and assignees, as board labels. */
+function tagsOf(item) {
+	const tags = [...(item.labels ?? []).map((label) => tagOf("tag", label.name)), ...(item.assignees ?? []).map((user) => tagOf("assignee", user.login))];
+	return Object.fromEntries(tags.filter((tag) => tag !== null));
+}
+/** Actions that change only labels and assignees, which every PR and issue event reconciles. */
+const TAG_ACTIONS = [
+	"labeled",
+	"unlabeled",
+	"assigned",
+	"unassigned"
+];
+/**
+* The label key prefixes the mirror owns on a GitHub root: keys under them that GitHub doesn't have are unset.
+* A prefix is owned only when the payload carries its array, so a trimmed payload doesn't unset every key.
+*/
+function ownedBy(item) {
+	return [...Array.isArray(item.labels) ? ["tag."] : [], ...Array.isArray(item.assignees) ? ["assignee."] : []];
+}
+/** Maps a raw `pull_request`, `pull_request_review`, or `issues` webhook to a lifecycle event. */
+function lifecycle(name, body) {
+	const action = String(body.action ?? "");
+	const sender = body.sender;
+	if (name === "pull_request") {
+		const pr = body.pull_request;
+		const pr_label = { pr: `${body.repository.full_name}#${pr.number}` };
+		const base = {
+			title: `PR #${pr.number}: ${pr.title}`,
+			url: pr.html_url,
+			unset: []
+		};
+		if (TAG_ACTIONS.includes(action)) return {
+			number: pr.number,
+			user: sender ?? {},
+			lifecycle: {
+				...base,
+				type: `pr.${action}`,
+				labels: {},
+				reply: null,
+				createRoot: false
+			}
+		};
+		switch (action) {
+			case "opened": return {
+				number: pr.number,
+				user: sender ?? {},
+				lifecycle: {
+					...base,
+					type: "pr.opened",
+					labels: {
+						...pr_label,
+						state: pr.draft ? "draft" : "open"
+					},
+					reply: null,
+					createRoot: true
+				}
+			};
+			case "ready_for_review": return {
+				number: pr.number,
+				user: sender ?? {},
+				lifecycle: {
+					...base,
+					type: "pr.ready",
+					labels: {
+						...pr_label,
+						state: "open"
+					},
+					reply: null,
+					createRoot: true
+				}
+			};
+			case "converted_to_draft": return {
+				number: pr.number,
+				user: sender ?? {},
+				lifecycle: {
+					...base,
+					type: "pr.draft",
+					labels: { state: "draft" },
+					reply: null,
+					createRoot: false
+				}
+			};
+			case "reopened": return {
+				number: pr.number,
+				user: sender ?? {},
+				lifecycle: {
+					...base,
+					type: "pr.reopened",
+					labels: {
+						...pr_label,
+						state: pr.draft ? "draft" : "open"
+					},
+					reply: `reopened by ${sender?.login ?? "someone"}`,
+					createRoot: true
+				}
+			};
+			case "closed": return {
+				number: pr.number,
+				user: sender ?? {},
+				lifecycle: {
+					...base,
+					type: "pr.closed",
+					labels: { state: pr.merged ? "merged" : "closed" },
+					reply: `${pr.merged ? "merged" : "closed"} by ${sender?.login ?? "someone"}`,
+					createRoot: false
+				}
+			};
+			default: return null;
+		}
+	}
+	if (name === "pull_request_review") {
+		const pr = body.pull_request;
+		const review = body.review;
+		const base = {
+			title: `PR #${pr.number}: ${pr.title}`,
+			url: pr.html_url,
+			createRoot: false
+		};
+		if (action === "dismissed") return {
+			number: pr.number,
+			user: sender ?? {},
+			lifecycle: {
+				...base,
+				type: "review.dismissed",
+				labels: {},
+				unset: ["review"],
+				reply: null
+			}
+		};
+		if (action !== "submitted") return null;
+		const state = String(review.state ?? "").toLowerCase();
+		const verdict = state === "approved" ? "approved" : state === "changes_requested" ? "changes requested" : null;
+		const text = [verdict ? `${verdict} by ${sender?.login ?? "someone"}` : null, review.body || null].filter(Boolean).join("\n\n");
+		if (!text) return null;
+		return {
+			number: pr.number,
+			user: sender ?? {},
+			lifecycle: {
+				...base,
+				type: "review.submitted",
+				labels: verdict ? { review: state } : {},
+				unset: [],
+				reply: text
+			}
+		};
+	}
+	if (name === "issues") {
+		const issue = body.issue;
+		const label = { issue: `${body.repository.full_name}#${issue.number}` };
+		const base = {
+			title: `Issue #${issue.number}: ${issue.title}`,
+			url: issue.html_url,
+			unset: []
+		};
+		if (TAG_ACTIONS.includes(action)) return {
+			number: issue.number,
+			user: sender ?? {},
+			lifecycle: {
+				...base,
+				type: `issue.${action}`,
+				labels: {},
+				reply: null,
+				createRoot: false
+			}
+		};
+		if (action === "opened") return {
+			number: issue.number,
+			user: sender ?? {},
+			lifecycle: {
+				...base,
+				type: "issue.opened",
+				labels: {
+					...label,
+					state: "open"
+				},
+				reply: null,
+				createRoot: true
+			}
+		};
+		if (action === "closed") return {
+			number: issue.number,
+			user: sender ?? {},
+			lifecycle: {
+				...base,
+				type: "issue.closed",
+				labels: { state: "closed" },
+				reply: `closed by ${sender?.login ?? "someone"}`,
+				createRoot: false
+			}
+		};
+		if (action === "reopened") return {
+			number: issue.number,
+			user: sender ?? {},
+			lifecycle: {
+				...base,
+				type: "issue.reopened",
+				labels: {
+					...label,
+					state: "open"
+				},
+				reply: `reopened by ${sender?.login ?? "someone"}`,
+				createRoot: true
+			}
+		};
+	}
+	return null;
+}
+const GitHubSubject = z.object({
+	type: z.enum(["pull_request", "issue"]),
+	repo: z.string(),
+	number: z.number().int().positive()
+});
+const NativeItem = z.looseObject({
+	number: z.number(),
+	title: z.string(),
+	html_url: z.string(),
+	body: z.string().nullable().optional(),
+	draft: z.boolean().optional(),
+	state: z.string().optional(),
+	base: z.looseObject({ ref: z.string() }).optional(),
+	head: z.looseObject({ ref: z.string() }).optional()
+});
+const GitHubPayload = z.looseObject({
+	pull_request: NativeItem.optional(),
+	issue: NativeItem.optional(),
+	action: z.string().optional()
+});
+const prTypes = [
+	"pr.opened",
+	"pr.ready",
+	"pr.draft",
+	"pr.reopened",
+	"pr.closed",
+	"pr.labeled",
+	"pr.unlabeled",
+	"pr.assigned",
+	"pr.unassigned",
+	"review.submitted",
+	"review.dismissed"
+];
+const issueTypes = [
+	"issue.opened",
+	"issue.closed",
+	"issue.reopened",
+	"issue.labeled",
+	"issue.unlabeled",
+	"issue.assigned",
+	"issue.unassigned"
+];
+const [messageEvent, editedEvent, deletedEvent, reactionEvent, lifecycleEvent] = eventSchema("github", "comment").options;
+const githubFields = {
+	subject: GitHubSubject,
+	raw: GitHubPayload
+};
+const prLifecycle = (type) => lifecycleEvent.extend({
+	type: z.literal(type),
+	subject: GitHubSubject.extend({ type: z.literal("pull_request") }),
+	raw: GitHubPayload.extend({ pull_request: NativeItem })
+});
+const issueLifecycle = (type) => lifecycleEvent.extend({
+	type: z.literal(type),
+	subject: GitHubSubject.extend({ type: z.literal("issue") }),
+	raw: GitHubPayload.extend({ issue: NativeItem })
+});
+const GitHubEvent = z.discriminatedUnion("type", [
+	messageEvent.extend(githubFields),
+	editedEvent.extend(githubFields),
+	deletedEvent.extend(githubFields),
+	reactionEvent.extend(githubFields),
+	...prTypes.map(prLifecycle),
+	...issueTypes.map(issueLifecycle)
+]);
+/** `owner/repo:12`, `owner/repo:issue:3`, or `owner/repo:12:rc:345` (a review comment thread). */
+function parseThread(thread) {
+	const match = /^([^/]+)\/([^:]+):(?:issue:)?(\d+)(?::rc:(\d+))?$/.exec(thread);
+	if (!match) throw new Error(`invalid GitHub thread: ${thread}`);
+	return {
+		owner: match[1],
+		repo: match[2],
+		number: Number(match[3]),
+		review: match[4] ? Number(match[4]) : null
+	};
+}
+/** GitHub's REST API with a person's own token: Chat SDK's adapter only holds the app's. */
+async function asPerson(token, method, path, body) {
+	const response = await fetch(`https://api.github.com${path}`, {
+		method,
+		headers: {
+			authorization: `Bearer ${token}`,
+			accept: "application/vnd.github+json",
+			"x-github-api-version": "2022-11-28",
+			...body === void 0 ? {} : { "content-type": "application/json" }
+		},
+		...body === void 0 ? {} : { body: JSON.stringify(body) }
+	});
+	if (!response.ok) {
+		const detail = await response.text().catch(() => "");
+		throw Object.assign(/* @__PURE__ */ new Error(`GitHub ${method} ${path}: ${response.status} ${detail.slice(0, 200)}`), { data: { error: `github_${response.status}` } });
+	}
+	return response.status === 204 ? null : response.json();
+}
+/**
+* Syncs GitHub repos with board channels. Keys are repos (`'owner/repo'`);
+* values are a board channel (PRs and issues become threads there), a
+* function, or `{ pulls, issues }` to send each somewhere else. Roots never
+* flow into GitHub: a board thread doesn't open an issue.
+*/
+function github(options) {
+	return new GitHubProvider(options);
+}
+/**
+* A connector's GitHub adapter, finding its own bot user ID. Chat SDK skips detection
+* with Connect's installation token, since REST's `/user` refuses it, and only learns
+* the ID from the first comment it posts, per instance. GraphQL's `viewer` answers with
+* the app's bot user for the same token.
+*/
+function fromConnector(connector, botUserId) {
+	const adapter = createGitHubAdapter({
+		...connectGitHubAdapter(connector),
+		...botUserId !== void 0 ? { botUserId } : {}
+	});
+	const detecting = adapter;
+	detecting.detectBotUserId = async (octokit) => {
+		if (detecting._botUserId !== null || !octokit.graphql) return;
+		try {
+			const { viewer } = await octokit.graphql("query { viewer { databaseId login } }");
+			if (typeof viewer?.databaseId !== "number") return;
+			detecting._botUserId = viewer.databaseId;
+			detecting.logger?.info("GitHub bot user ID detected from the GraphQL viewer", {
+				botUserId: viewer.databaseId,
+				login: viewer.login
+			});
+		} catch (error) {
+			detecting.logger?.warn("Could not detect the GitHub bot user ID", { error });
+		}
+	};
+	return withUserTokens(adapter, connectUserTokens(connector));
+}
+var GitHubProvider = class extends ChatSyncProvider {
+	body;
+	constructor(given) {
+		const options = {
+			...given,
+			adapter: typeof given.adapter === "string" ? fromConnector(given.adapter, given.botUserId) : given.adapter
+		};
+		super({
+			render: options.render,
+			platform: "github",
+			adapter: options.adapter,
+			canStartThreads: false,
+			mention: (actor) => actor.id.startsWith("github:user:") ? `@${actor.handle}` : null,
+			resolveChannel: (key) => Promise.resolve(key),
+			groupThread: (thread) => thread.replace(/:rc:[^:]+$/, ""),
+			channelOf,
+			isRoot: () => false,
+			async fetchRoot(thread) {
+				const match = /^([^/]+)\/([^:]+):(issue:)?(\d+)$/.exec(thread);
+				if (!match) throw new Error(`invalid GitHub thread: ${thread}`);
+				const [, owner, repo, issue, number] = match;
+				const client = options.adapter.octokit.rest;
+				const { data } = issue ? await client.issues.get({
+					owner,
+					repo,
+					issue_number: Number(number)
+				}) : await client.pulls.get({
+					owner,
+					repo,
+					pull_number: Number(number)
+				});
+				return {
+					text: `${issue ? "Issue" : "PR"} #${data.number}: ${data.title}\n${data.html_url}`,
+					raw: issue ? { issue: data } : { pull_request: data },
+					author: author(data.user),
+					labels: {
+						...tagsOf(data),
+						[issue ? "issue" : "pr"]: `${owner}/${repo}#${data.number}`,
+						state: issue ? data.state : data.merged ? "merged" : data.state === "closed" ? "closed" : data.draft ? "draft" : "open"
+					}
+				};
+			},
+			markdown(message) {
+				const raw = message.raw;
+				const body = raw?.comment?.body ?? raw?.body;
+				return typeof body === "string" && body.trim() ? body.trim() : markdownOf(message);
+			},
+			async avatar(message) {
+				const raw = message.raw;
+				const url = raw?.comment?.user?.avatar_url ?? raw?.user?.avatar_url;
+				return typeof url === "string" ? url : null;
+			},
+			context(message) {
+				const raw = message.raw;
+				const path = raw?.path ?? raw?.comment?.path;
+				const line = raw?.line ?? raw?.comment?.line;
+				return path ? line ? `${path}:${line}` : path : null;
+			},
+			missed(headers, body) {
+				const name = headers.get("x-github-event") ?? "";
+				if (name !== "issue_comment" && name !== "pull_request_review_comment") return [];
+				let payload;
+				try {
+					payload = JSON.parse(body);
+				} catch {
+					return [];
+				}
+				if (payload.action !== "edited" && payload.action !== "deleted" || !payload.comment?.id || !payload.repository) return [];
+				const { comment, repository } = payload;
+				const adapter = options.adapter;
+				const review = name === "pull_request_review_comment";
+				const number = review ? payload.pull_request?.number : payload.issue?.number;
+				if (!number) return [];
+				const type = review ? void 0 : payload.issue?.pull_request ? "pr" : "issue";
+				const threadId = adapter.encodeThreadId({
+					owner: repository.owner.login,
+					repo: repository.name,
+					prNumber: number,
+					...review ? { reviewCommentId: comment.in_reply_to_id ?? comment.id } : { type }
+				});
+				const message = review ? adapter.parseReviewComment(comment, repository, number, threadId) : adapter.parseIssueComment(comment, repository, number, threadId, type);
+				if (message.author.isMe) return [];
+				return payload.action === "edited" ? [{
+					kind: "edited",
+					message
+				}] : [{
+					kind: "deleted",
+					thread: threadId,
+					message: message.id,
+					raw: payload
+				}];
+			},
+			intercept(key, headers, body) {
+				const name = headers.get("x-github-event") ?? "";
+				if (![
+					"pull_request",
+					"pull_request_review",
+					"issues"
+				].includes(name)) return [];
+				let parsed;
+				try {
+					parsed = JSON.parse(body);
+				} catch {
+					return [];
+				}
+				const found = lifecycle(name, parsed);
+				if (!found) return [];
+				const item = parsed.pull_request ?? parsed.issue;
+				if (item) Object.assign(found.lifecycle, {
+					labels: {
+						...tagsOf(item),
+						...found.lifecycle.labels
+					},
+					owns: ownedBy(item)
+				});
+				const repo = parsed.repository.full_name;
+				const thread = name === "issues" ? `${key}:${repo}:issue:${found.number}` : `${key}:${repo}:${found.number}`;
+				const delivery = headers.get("x-github-delivery") ?? `${name}:${found.lifecycle.type}:${found.number}`;
+				return [{
+					event: {
+						kind: "lifecycle",
+						channel: `${key}:${repo}:${name === "issues" ? "issues" : "pulls"}`,
+						thread,
+						author: author(found.user),
+						...found.lifecycle
+					},
+					raw: parsed,
+					dedupe: `lifecycle:${delivery}`
+				}];
+			},
+			async resolveTarget(target) {
+				if (!/^[^/]+\/[^:]+(?::(?:issue:)?\d+(?::rc:[^:]+)?)?$/.test(target)) throw new Error(`invalid GitHub target: ${target}`);
+				const at = target.indexOf(":");
+				return {
+					target,
+					channel: at === -1 ? target : channelOf(target),
+					kind: at === -1 ? "channel" : "thread"
+				};
+			}
+		});
+		const converter = options.adapter.formatConverter;
+		this.body = (post) => {
+			try {
+				return converter ? converter.renderPostable({ markdown: post.markdown }) : post.markdown;
+			} catch {
+				return post.markdown;
+			}
+		};
+		for (const [repo, value] of Object.entries(options.repos)) {
+			const { pulls, issues } = typeof value === "object" && !("run" in value) ? value : {
+				pulls: value,
+				issues: value
+			};
+			if (pulls) this.map(`${repo}:pulls`, pulls);
+			if (issues) this.map(`${repo}:issues`, issues);
+		}
+	}
+	async whoAmI(token) {
+		const user = await asPerson(token, "GET", "/user");
+		if (!user.id) throw new Error("GitHub didn't say whose token this is");
+		return {
+			...author(user),
+			isBot: false
+		};
+	}
+	async postAs(token, target, kind, post) {
+		if (kind === "channel") throw new Error("github cannot start threads");
+		const { owner, repo, number, review } = parseThread(target);
+		const body = this.body(post);
+		const comment = await (review !== null ? asPerson(token, "POST", `/repos/${owner}/${repo}/pulls/${number}/comments/${review}/replies`, { body }) : asPerson(token, "POST", `/repos/${owner}/${repo}/issues/${number}/comments`, { body }));
+		return {
+			thread: target,
+			message: String(comment.id)
+		};
+	}
+	async editAs(token, thread, message, post) {
+		const { owner, repo, review } = parseThread(thread);
+		await asPerson(token, "PATCH", `/repos/${owner}/${repo}/${review !== null ? "pulls" : "issues"}/comments/${message}`, { body: this.body(post) });
+	}
+	async deleteAs(token, thread, message) {
+		const { owner, repo, review } = parseThread(thread);
+		await asPerson(token, "DELETE", `/repos/${owner}/${repo}/${review !== null ? "pulls" : "issues"}/comments/${message}`);
+	}
+	/**
+	* A thread's root is the PR or issue itself, not a comment: its copy has no comment ID
+	* (`root:<event>` or `lifecycle:<event>`), so its reactions go on the PR or issue.
+	*/
+	async react(thread, message, emoji, added) {
+		if (/^\d+$/.test(message)) return super.react(thread, message, emoji, added);
+		const match = /^([^/]+)\/([^:]+):(?:issue:)?(\d+)$/.exec(thread);
+		if (!match) throw new Error(`invalid GitHub thread: ${thread}`);
+		const adapter = await this.ready();
+		const content = adapter.emojiToGitHubReaction?.(emoji);
+		if (!content || content === "+1" && emoji !== "thumbs_up" && emoji !== "+1") return;
+		const [, owner, repo, number] = match;
+		const reactions = (await adapter.getOctokitForThread?.(owner, repo) ?? adapter.octokit).rest.reactions;
+		if (!reactions) throw new Error("GitHub client has no reactions API");
+		const where = {
+			owner,
+			repo,
+			issue_number: Number(number)
+		};
+		if (added) return void await reactions.createForIssue({
+			...where,
+			content
+		});
+		if (adapter.botUserId === void 0) return;
+		const { data } = await reactions.listForIssue({
+			...where,
+			content,
+			per_page: 100
+		});
+		const own = data.find((reaction) => reaction.content === content && String(reaction.user?.id) === adapter.botUserId);
+		if (own) await reactions.deleteForIssue({
+			...where,
+			reaction_id: own.id
+		});
+	}
+	event(context) {
+		const match = /^([^:]+):(issue:)?(\d+)/.exec(context.event.thread.slice(context.key.length + 1));
+		if (!match) throw new Error(`invalid GitHub thread: ${context.event.thread}`);
+		const base = envelope(this.platform, context.key, context.event, context.raw ?? {}, context.id);
+		return GitHubEvent.parse({
+			...base,
+			type: context.event.kind === "message" ? "comment" : base.type,
+			subject: {
+				type: match[2] ? "issue" : "pull_request",
+				repo: match[1],
+				number: Number(match[3])
+			}
+		});
+	}
+};
+//#endregion
+export { GitHubEvent, GitHubPayload, GitHubProvider, github, withUserTokens };