@mastra/factory 0.0.0-fix-thread-subscription-multi-instance-redis-streams-20260730204150

package/dist/integrations/platform/github/integration.js

@@ -0,0 +1,961 @@
+import { createGithubSubscriptionTools, parseCreatedPullRequest, subscribeCurrentSessionToPullRequest } from "../../github/session-subscriptions.js";
+import { runGithubIssueTriage } from "../../github/issue-triage.js";
+import { buildGithubRoutes } from "../../github/routes.js";
+import { attachGithubReconciler, attachGithubRules } from "../../github/rules.js";
+import { PlatformApiClient, PlatformApiError, logPlatformInfo, logPlatformWarn, platformApiClientConfigFromEnv } from "../api-client.js";
+import { PlatformGithubEventWorker } from "./event-worker.js";
+import { registerApiRoute } from "@mastra/core/server";
+//#region src/integrations/platform/github/integration.ts
+const PAGE_SIZE = 30;
+const API_PREFIX = "/v1/server";
+/**
+* How long an installation's repository listing may be reused. The repos
+* route and token minting both call it — often several times within one UI
+* interaction — and each call is a full Platform round trip.
+*/
+const INSTALLATION_REPOS_CACHE_TTL_MS = 3e4;
+/**
+* How long a minted repository-scoped token may be reused. GitHub
+* installation tokens live ~60 minutes; 5 minutes keeps a wide validity
+* margin while collapsing the per-session-materialization mint round trip.
+*/
+const REPOSITORY_ACCESS_CACHE_TTL_MS = 5 * 6e4;
+/**
+* Upper bound for both TTL caches. Entries expire lazily on re-access, so
+* without a hard cap keys that stop being queried would accumulate for the
+* integration's (long) lifetime. Insertion-order eviction — matches the
+* bounded verification cache in `@mastra/auth-studio`.
+*/
+const MAX_CACHE_ENTRIES = 1e3;
+function setBounded(cache, key, value) {
+	cache.delete(key);
+	cache.set(key, value);
+	if (cache.size > MAX_CACHE_ENTRIES) {
+		const oldest = cache.keys().next().value;
+		if (oldest !== void 0) cache.delete(oldest);
+	}
+}
+const REPOSITORY_TOKEN_PERMISSIONS = {
+	contents: "write",
+	issues: "write",
+	pull_requests: "write"
+};
+function loose(c) {
+	return c;
+}
+function routeBaseUrl(ctx, requestUrl) {
+	return (ctx.baseUrl || new URL(requestUrl).origin).replace(/\/+$/, "");
+}
+var PlatformGithubIntegration = class {
+	id = "github";
+	#client;
+	#endpointHost;
+	#pollingEnabled;
+	#pollingIntervalMs;
+	#reconcileEnabled;
+	#storage;
+	#integrationStorage;
+	/** installationId → cached repository listing (TTL-bounded). */
+	#installationReposCache = /* @__PURE__ */ new Map();
+	/** `orgId:repositoryId` → cached repository access (TTL-bounded). */
+	#repositoryAccessCache = /* @__PURE__ */ new Map();
+	#runIssueTriage;
+	intake = {
+		resolveIntakeDispatch: (input) => this.#resolveIntakeDispatch(input),
+		listSources: async ({ orgId, userId }) => {
+			const usable = (await this.#client.request("GET", `${API_PREFIX}/github-app/installations`)).installations.filter((installation) => installation.usable && !installation.suspendedAt);
+			return (await Promise.all(usable.map(async (installation) => {
+				const storedInstallation = await this.versionControl.registerInstallation({
+					orgId,
+					userId,
+					installation: {
+						externalId: String(installation.installationId),
+						accountName: installation.accountLogin,
+						accountType: installation.accountType
+					}
+				});
+				const result = await this.#client.request("GET", `${API_PREFIX}/github-app/installations/${installation.installationId}/repositories`);
+				await this.versionControl.registerRepositories({
+					orgId,
+					installationId: storedInstallation.id,
+					repositories: result.repositories.map((repository) => ({
+						externalId: String(repository.id),
+						slug: repository.fullName,
+						defaultBranch: repository.defaultBranch,
+						metadata: {
+							private: repository.private,
+							url: repository.htmlUrl
+						}
+					}))
+				});
+				return result.repositories.map((repository) => ({
+					repository,
+					installation
+				}));
+			}))).flat().map(({ repository, installation }) => ({
+				id: repository.fullName,
+				name: repository.fullName,
+				type: "repository",
+				metadata: {
+					installationId: installation.installationId,
+					accountLogin: installation.accountLogin,
+					accountType: installation.accountType,
+					repositoryId: repository.id,
+					defaultBranch: repository.defaultBranch,
+					private: repository.private,
+					url: repository.htmlUrl
+				}
+			}));
+		},
+		listItems: async ({ sourceIds, cursor }) => {
+			const page = parsePositiveCursor(cursor);
+			const pages = await Promise.all(sourceIds.map(async (sourceId) => {
+				const connection = {
+					type: "app-installation",
+					installationId: 1
+				};
+				const [issues, pullRequests] = await Promise.all([this.#listIssues(connection, sourceId, page), this.#listPullRequests({
+					connection,
+					sourceId,
+					includeDrafts: false,
+					cursor: String(page)
+				})]);
+				return {
+					items: [...issues.issues.map((issue) => ({
+						source: {
+							type: "issue",
+							externalId: `${sourceId}:${issue.id}`,
+							url: issue.url
+						},
+						sourceId,
+						title: issue.title,
+						status: issue.state ?? void 0,
+						labels: issue.labels,
+						assignee: issue.assignee,
+						createdAt: issue.createdAt,
+						updatedAt: issue.updatedAt,
+						metadata: {
+							repository: sourceId,
+							number: Number(issue.id),
+							author: issue.author
+						}
+					})), ...pullRequests.pullRequests.map((pullRequest) => ({
+						source: {
+							type: "pull-request",
+							externalId: `${sourceId}:${pullRequest.id}`,
+							url: pullRequest.url
+						},
+						sourceId,
+						title: pullRequest.title,
+						status: pullRequest.state,
+						createdAt: pullRequest.createdAt,
+						updatedAt: pullRequest.updatedAt,
+						metadata: {
+							repository: sourceId,
+							number: Number(pullRequest.id),
+							author: pullRequest.author,
+							baseBranch: pullRequest.baseBranch,
+							headBranch: pullRequest.headBranch
+						}
+					}))],
+					hasNextPage: issues.nextCursor !== null || pullRequests.nextCursor !== null
+				};
+			}));
+			return {
+				items: pages.flatMap((result) => result.items),
+				nextCursor: pages.some((result) => result.hasNextPage) ? String(page + 1) : null
+			};
+		},
+		listIssues: async (input) => {
+			requireGithubConnection(input.connection);
+			const sourceId = requireSingleSource(input.sourceIds, "GitHub Intake requires exactly one repository source.");
+			return this.#listIssues(input.connection, sourceId, parsePositiveCursor(input.cursor), input.labels);
+		},
+		getIssue: (input) => this.#getIssue(input.connection, input.sourceId, input.issueId),
+		createComment: (input) => this.#createIssueComment(input),
+		updateIssue: (input) => this.#updateIntakeIssue(input)
+	};
+	versionControl = {
+		initialize: ({ storage }) => {
+			this.#storage = storage;
+		},
+		registerInstallation: ({ orgId, userId, installation }) => this.storage.installations.upsert({
+			orgId,
+			connectedByUserId: userId,
+			externalId: installation.externalId,
+			accountName: installation.accountName,
+			accountType: installation.accountType,
+			providerMetadata: installation.metadata
+		}),
+		registerRepositories: ({ orgId, installationId, repositories }) => Promise.all(repositories.map((repository) => this.storage.repositories.upsert({
+			orgId,
+			input: {
+				installationId,
+				externalId: repository.externalId,
+				slug: repository.slug,
+				defaultBranch: repository.defaultBranch,
+				providerMetadata: repository.metadata
+			}
+		}))),
+		getRepositoryAccess: async ({ orgId, repositoryId }) => {
+			const cacheKey = `${orgId}:${repositoryId}`;
+			const cached = this.#repositoryAccessCache.get(cacheKey);
+			if (cached && cached.expiresAt > Date.now()) return cached.access;
+			this.#repositoryAccessCache.delete(cacheKey);
+			const repository = await this.storage.repositories.get({
+				orgId,
+				id: repositoryId
+			});
+			if (!repository) throw new Error("Version-control repository not found.");
+			const cloneUrl = `https://github.com/${repository.slug}.git`;
+			const installation = await this.storage.installations.get({
+				orgId,
+				id: repository.installationId
+			});
+			if (!installation) throw new Error("Version-control installation not found.");
+			const installationId = parsePositiveInteger(installation.externalId);
+			if (installationId === null) throw new Error("GitHub installation id is invalid.");
+			const repositoryName = splitRepository(repository.slug).repo;
+			try {
+				const access = {
+					cloneUrl,
+					authorization: {
+						scheme: "bearer",
+						token: (await this.#client.request("POST", `${API_PREFIX}/github-app/installations/${installationId}/token`, {
+							repositories: [repositoryName],
+							permissions: REPOSITORY_TOKEN_PERMISSIONS
+						})).token
+					}
+				};
+				setBounded(this.#repositoryAccessCache, cacheKey, {
+					access,
+					expiresAt: Date.now() + REPOSITORY_ACCESS_CACHE_TTL_MS
+				});
+				return access;
+			} catch (err) {
+				if (!isNotFound(err) || !installation.accountName) throw err;
+				const newInstallation = (await this.storage.installations.list({ orgId })).find((inst) => inst.accountName === installation.accountName && inst.id !== installation.id);
+				if (!newInstallation) throw err;
+				const newInstallationId = parsePositiveInteger(newInstallation.externalId);
+				if (newInstallationId === null) throw err;
+				await this.storage.repositories.migrateInstallation({
+					orgId,
+					id: repositoryId,
+					newInstallationId: newInstallation.id
+				});
+				const access = {
+					cloneUrl,
+					authorization: {
+						scheme: "bearer",
+						token: (await this.#client.request("POST", `${API_PREFIX}/github-app/installations/${newInstallationId}/token`, {
+							repositories: [repositoryName],
+							permissions: REPOSITORY_TOKEN_PERMISSIONS
+						})).token
+					}
+				};
+				setBounded(this.#repositoryAccessCache, cacheKey, {
+					access,
+					expiresAt: Date.now() + REPOSITORY_ACCESS_CACHE_TTL_MS
+				});
+				return access;
+			}
+		},
+		listPullRequests: (input) => this.#listPullRequests(input),
+		getPullRequest: (input) => this.#getPullRequest(input),
+		createPullRequest: (input) => this.#createPullRequest(input),
+		updatePullRequest: (input) => this.#updatePullRequest(input),
+		closePullRequest: (input) => this.#updatePullRequest({
+			...input,
+			state: "closed"
+		}),
+		mergePullRequest: (input) => this.#mergePullRequest(input),
+		listComments: (input) => this.#listComments(input),
+		createComment: (input) => this.#createComment(input),
+		updateComment: (input) => this.#updateComment(input),
+		deleteComment: (input) => this.#deleteComment(input),
+		listReviews: (input) => this.#listReviews(input),
+		getReview: (input) => this.#getReview(input),
+		createReview: (input) => this.#createReview(input),
+		updateReview: (input) => this.#updateReview(input),
+		submitReview: (input) => this.#submitReview(input),
+		dismissReview: (input) => this.#dismissReview(input),
+		deletePendingReview: (input) => this.#deletePendingReview(input),
+		listReviewComments: (input) => this.#listReviewComments(input),
+		createReviewComment: (input) => this.#createReviewComment(input),
+		updateReviewComment: (input) => this.#updateReviewComment(input),
+		deleteReviewComment: (input) => this.#deleteReviewComment(input),
+		listRequestedReviewers: (input) => this.#requestedReviewers("GET", input),
+		requestReviewers: (input) => this.#requestedReviewers("POST", input),
+		removeRequestedReviewers: (input) => this.#requestedReviewers("DELETE", input)
+	};
+	constructor(options = {}) {
+		const config = platformApiClientConfigFromEnv();
+		this.#client = new PlatformApiClient(config);
+		this.#endpointHost = new URL(config.baseUrl).host;
+		this.#pollingEnabled = process.env.MASTRA_PLATFORM_GITHUB_POLLING_ENABLED?.trim().toLowerCase() !== "false";
+		this.#pollingIntervalMs = optionalPositiveIntegerEnv("MASTRA_PLATFORM_GITHUB_POLLING_INTERVAL_MS");
+		this.#reconcileEnabled = process.env.MASTRA_PLATFORM_GITHUB_RECONCILE_ENABLED?.trim().toLowerCase() !== "false";
+		this.#runIssueTriage = options.runIssueTriage;
+	}
+	get storage() {
+		if (!this.#storage) throw new Error("PlatformGithubIntegration source-control storage has not been initialized.");
+		return this.#storage;
+	}
+	get sourceControlStorage() {
+		return this.storage;
+	}
+	get integrationStorage() {
+		if (!this.#integrationStorage) throw new Error("PlatformGithubIntegration generic storage has not been initialized.");
+		return this.#integrationStorage;
+	}
+	/** Resolve a stored GitHub locator without scanning installations or repositories. */
+	async #resolveIntakeDispatch({ orgId, externalSource }) {
+		const target = parseGithubExternalTarget(externalSource.externalId);
+		if (!target) return null;
+		const repository = target.repository.includes("/") ? target.repository : (await this.storage.repositories.findByExternalId({
+			orgId,
+			externalId: target.repository
+		}))?.slug;
+		if (!repository) return null;
+		return {
+			connection: {
+				type: "app-installation",
+				installationId: 1
+			},
+			sourceId: repository,
+			issueId: target.issueId
+		};
+	}
+	initialize({ storage }) {
+		this.#integrationStorage = storage;
+		logPlatformInfo("Platform GitHub integration initialized", {
+			endpointHost: this.#endpointHost,
+			pollingEnabled: this.#pollingEnabled,
+			pollingIntervalMs: this.#pollingIntervalMs,
+			reconcileEnabled: this.#reconcileEnabled
+		});
+	}
+	routes(ctx) {
+		const ingestFactoryEvent = attachGithubRules(this, ctx);
+		return [
+			this.#statusRoute(ctx),
+			this.#connectRoute(ctx),
+			this.#connectUserRoute(ctx),
+			...buildGithubRoutes({
+				auth: ctx.auth,
+				fleet: ctx.fleet,
+				storage: ctx.factoryStorage,
+				github: this,
+				stateSigner: ctx.stateSigner,
+				baseUrl: ctx.baseUrl,
+				controller: ctx.controller,
+				projects: ctx.storage.projects,
+				emitAudit: ctx.hooks?.emitAudit,
+				ingestFactoryEvent,
+				runIssueTriage: this.#runIssueTriage ?? (ctx.controller ? (input) => runGithubIssueTriage({
+					controller: ctx.controller,
+					input
+				}) : void 0)
+			}).filter((route) => route.path !== "/web/github/status" && route.path !== "/web/github/webhook" && !route.path.startsWith("/auth/github/"))
+		];
+	}
+	#statusRoute(ctx) {
+		return registerApiRoute("/web/github/status", {
+			method: "GET",
+			requiresAuth: false,
+			handler: async (c) => {
+				await ctx.auth.ensureUser(loose(c));
+				const tenant = ctx.auth.tenant(loose(c));
+				if (!tenant) return c.json({
+					error: "unauthorized",
+					reason: "auth_required"
+				}, 401);
+				if (!tenant.orgId) return c.json({
+					enabled: true,
+					sandboxEnabled: ctx.fleet.enabled,
+					organizationRequired: true,
+					connected: false,
+					installations: [],
+					userConnected: false,
+					userGithubUsername: null,
+					reason: "organization_required",
+					diagnostics: this.diagnostics()
+				});
+				const [installations, userConnection] = await Promise.all([this.#syncInstallations(tenant.orgId, tenant.userId), this.#fetchUserConnection(tenant.userId)]);
+				return c.json({
+					enabled: true,
+					sandboxEnabled: ctx.fleet.enabled,
+					connected: installations.length > 0,
+					installations: installations.map((installation) => ({
+						installationId: Number(installation.externalId),
+						accountLogin: installation.accountName,
+						accountType: installation.accountType
+					})),
+					userConnected: userConnection.connected,
+					userGithubUsername: userConnection.githubUsername,
+					reason: installations.length > 0 ? "ready" : "not_connected",
+					diagnostics: this.diagnostics()
+				});
+			}
+		});
+	}
+	#connectRoute(ctx) {
+		return registerApiRoute("/auth/github/connect", {
+			method: "GET",
+			requiresAuth: false,
+			handler: async (c) => {
+				await ctx.auth.ensureUser(loose(c));
+				const tenant = ctx.auth.tenant(loose(c));
+				if (!tenant?.orgId) return c.json({ error: "unauthorized" }, 401);
+				const redirectTo = c.req.query("redirectTo") || c.req.query("return_to") || "/";
+				const originator = routeBaseUrl(ctx, c.req.url);
+				logPlatformInfo("Starting Platform GitHub connect flow", {
+					orgId: tenant.orgId,
+					redirectTo,
+					originator
+				});
+				const query = new URLSearchParams({
+					action: "install",
+					redirectTo,
+					originator
+				});
+				const { url } = await this.#client.request("GET", `${API_PREFIX}/github-app/install-url?${query}`);
+				return c.redirect(url);
+			}
+		});
+	}
+	#connectUserRoute(ctx) {
+		return registerApiRoute("/auth/github/connect-user", {
+			method: "GET",
+			requiresAuth: false,
+			handler: async (c) => {
+				await ctx.auth.ensureUser(loose(c));
+				const tenant = ctx.auth.tenant(loose(c));
+				if (!tenant?.orgId) return c.json({ error: "unauthorized" }, 401);
+				const redirectTo = c.req.query("redirectTo") || c.req.query("return_to") || "/";
+				const originator = routeBaseUrl(ctx, c.req.url);
+				logPlatformInfo("Starting Platform GitHub user authorization flow", {
+					orgId: tenant.orgId,
+					redirectTo,
+					originator
+				});
+				const query = new URLSearchParams({
+					userId: tenant.userId,
+					redirectTo,
+					originator
+				});
+				const { url } = await this.#client.request("GET", `${API_PREFIX}/github-app/authenticate?${query}`);
+				return c.redirect(url);
+			}
+		});
+	}
+	/**
+	* Personal GitHub connection status for the acting user. Returns
+	* not-connected when the platform predates the user-connection endpoint.
+	*/
+	async #fetchUserConnection(userId) {
+		try {
+			const connection = await this.#client.request("GET", `${API_PREFIX}/github-app/user-connection?${new URLSearchParams({ userId })}`);
+			if (!connection.connected && connection.reason) logPlatformWarn("Platform GitHub user connection verification failed", {
+				userId,
+				reason: connection.reason
+			});
+			return connection;
+		} catch {
+			return {
+				connected: false,
+				githubUsername: null
+			};
+		}
+	}
+	async #syncInstallations(orgId, userId) {
+		const usableInstallations = (await this.#client.request("GET", `${API_PREFIX}/github-app/installations`)).installations.filter((installation) => installation.usable && !installation.suspendedAt);
+		return Promise.all(usableInstallations.map((installation) => this.versionControl.registerInstallation({
+			orgId,
+			userId,
+			installation: {
+				externalId: String(installation.installationId),
+				accountName: installation.accountLogin,
+				accountType: installation.accountType
+			}
+		})));
+	}
+	workers(ctx) {
+		if (!this.#pollingEnabled && !this.#reconcileEnabled) return [];
+		if (!ctx.controller) throw new Error("Platform GitHub event polling requires the mounted Mastra Code controller.");
+		return [new PlatformGithubEventWorker({
+			client: this.#client,
+			controller: ctx.controller,
+			github: this,
+			storage: ctx.storage.generic,
+			ingestFactoryEvent: attachGithubRules(this, ctx),
+			reconcileFactoryState: this.#reconcileEnabled ? attachGithubReconciler(this, ctx, (input) => this.fetchPullRequestState(input)) : void 0,
+			pollEventsEnabled: this.#pollingEnabled,
+			intervalMs: this.#pollingIntervalMs
+		})];
+	}
+	/**
+	* Reads live PR state through the Platform GitHub proxy for the merge
+	* reconciler. Returns undefined when the PR cannot be resolved (missing,
+	* proxy error) so a sweep never fabricates a merge.
+	*/
+	async fetchPullRequestState(input) {
+		let repository;
+		try {
+			repository = splitRepository(input.repository);
+		} catch {
+			return;
+		}
+		try {
+			const result = await this.#client.request("GET", `${API_PREFIX}/github/repos/${encodeURIComponent(repository.owner)}/${encodeURIComponent(repository.repo)}/pulls/${input.number}`);
+			return {
+				title: result.title ?? `PR ${input.number}`,
+				url: result.html_url ?? `https://github.com/${input.repository}/pull/${input.number}`,
+				state: result.state === "closed" ? "closed" : "open",
+				merged: result.merged === true,
+				headBranch: result.head?.ref ?? "",
+				baseBranch: result.base?.ref ?? "",
+				...result.created_at ? { createdAt: result.created_at } : {},
+				...result.merged_by?.login ? { mergedBy: result.merged_by.login } : {}
+			};
+		} catch {
+			return;
+		}
+	}
+	sessionTools({ requestContext }) {
+		return createGithubSubscriptionTools(requestContext, this);
+	}
+	async postToolObserver({ toolContext, requestContext }) {
+		const pullRequestUrl = parseCreatedPullRequest(toolContext);
+		if (!pullRequestUrl || !requestContext) return;
+		await subscribeCurrentSessionToPullRequest(requestContext, pullRequestUrl, "auto-gh-pr-create", this);
+	}
+	diagnostics() {
+		return {
+			mode: "platform",
+			endpointHost: this.#endpointHost,
+			polling: {
+				enabled: this.#pollingEnabled,
+				...this.#pollingIntervalMs === void 0 ? {} : { intervalMs: this.#pollingIntervalMs }
+			},
+			reconcile: { enabled: this.#reconcileEnabled }
+		};
+	}
+	async getRepositoryCollaboratorPermission(_installationId, repoFullName, username, signal) {
+		let repository;
+		try {
+			repository = splitRepository(repoFullName);
+		} catch {
+			return;
+		}
+		try {
+			return (await this.#client.request("GET", `${API_PREFIX}/github/repos/${encodeURIComponent(repository.owner)}/${encodeURIComponent(repository.repo)}/collaborators/${encodeURIComponent(username)}/permission`, void 0, { signal })).permission;
+		} catch {
+			return;
+		}
+	}
+	async listInstallationRepos(installationId) {
+		const cached = this.#installationReposCache.get(installationId);
+		if (cached && cached.expiresAt > Date.now()) return cached.repos;
+		this.#installationReposCache.delete(installationId);
+		const repos = (await this.#client.request("GET", `${API_PREFIX}/github-app/installations/${installationId}/repositories`)).repositories.map((repository) => ({
+			...repository,
+			installationId
+		}));
+		setBounded(this.#installationReposCache, installationId, {
+			repos,
+			expiresAt: Date.now() + INSTALLATION_REPOS_CACHE_TTL_MS
+		});
+		return repos;
+	}
+	async mintInstallationToken(installationId) {
+		const repositories = await this.listInstallationRepos(installationId);
+		if (repositories.length === 0 || repositories.length > 10) throw new Error("Platform GitHub token minting requires between one and ten installation repositories.");
+		return (await this.#client.request("POST", `${API_PREFIX}/github-app/installations/${installationId}/token`, {
+			repositories: repositories.map((repository) => repository.name),
+			permissions: REPOSITORY_TOKEN_PERMISSIONS
+		})).token;
+	}
+	async addIssueLabels(_installationId, sourceId, issueNumber, labels) {
+		return (await this.#client.request("POST", repositoryPath(sourceId, `issues/${issueNumber}/labels`), { labels })).labels;
+	}
+	getInstallationOctokit(_installationId) {
+		return { pulls: { get: async ({ owner, repo, pull_number }) => {
+			return { data: { base: { repo: { id: (await this.#client.request("GET", repositoryPath(`${owner}/${repo}`, `pulls/${pull_number}`))).base.repo.id } } } };
+		} } };
+	}
+	async #listIssues(connection, sourceId, page, labels) {
+		requireGithubConnection(connection);
+		const path = repositoryPath(sourceId, "issues");
+		const query = new URLSearchParams({
+			state: "open",
+			page: String(page),
+			per_page: String(PAGE_SIZE)
+		});
+		const normalizedLabels = normalizeLabels(labels);
+		if (normalizedLabels.length > 0) query.set("label", normalizedLabels.join(","));
+		const result = await this.#client.request("GET", `${path}?${query}`);
+		return {
+			issues: result.issues.map((issue) => parseIntakeIssue(sourceId, issue)),
+			nextCursor: result.issues.length === PAGE_SIZE ? String(page + 1) : null
+		};
+	}
+	async #getIssue(connection, sourceId, issueId) {
+		requireGithubConnection(connection);
+		const repository = requireSource(sourceId, "GitHub Intake requires a repository source.");
+		const issueNumber = requirePositiveId(issueId, "issue");
+		try {
+			const [issue, comments] = await Promise.all([this.#client.request("GET", repositoryPath(repository, `issues/${issueNumber}`)), this.#client.request("GET", `${repositoryPath(repository, `issues/${issueNumber}/comments`)}?per_page=100`)]);
+			return parseIntakeIssueDetail(repository, issue, comments.comments);
+		} catch (error) {
+			if (isNotFound(error)) return null;
+			throw error;
+		}
+	}
+	async #updateIntakeIssue(input) {
+		requireGithubConnection(input.connection);
+		const repository = requireSource(input.sourceId, "GitHub Intake requires a repository source.");
+		const issueNumber = requirePositiveId(input.issueId, "issue");
+		if (input.state.kind === "byName") {
+			logPlatformWarn(`Platform GitHub: updateIssue byName is not supported (name=${input.state.name}); ignoring.`);
+			return null;
+		}
+		const targetState = input.state.stateType === "unstarted" || input.state.stateType === "started" ? "open" : "closed";
+		const stateReason = targetState === "closed" ? input.state.stateType === "canceled" ? "not_planned" : "completed" : null;
+		try {
+			await this.#client.request("GET", repositoryPath(repository, `pulls/${issueNumber}`));
+			logPlatformWarn(`Platform GitHub: updateIssue rejected — target ${repository}#${issueNumber} is a pull request.`);
+			return null;
+		} catch (error) {
+			if (!isNotFound(error)) throw error;
+		}
+		try {
+			return parseIntakeIssue(repository, await this.#client.request("PATCH", repositoryPath(repository, `issues/${issueNumber}`), {
+				state: targetState,
+				...stateReason ? { state_reason: stateReason } : {}
+			}, { actingUserId: input.actingUserId }));
+		} catch (error) {
+			if (isNotFound(error)) return null;
+			throw error;
+		}
+	}
+	async #createIssueComment(input) {
+		requireGithubConnection(input.connection);
+		const repository = requireSource(input.sourceId, "GitHub Intake requires a repository source.");
+		const issueNumber = requirePositiveId(input.issueId, "issue");
+		try {
+			const comment = await this.#client.request("POST", repositoryPath(repository, `issues/${issueNumber}/comments`), { body: input.body }, { actingUserId: input.actingUserId });
+			return {
+				id: String(comment.id),
+				url: comment.htmlUrl
+			};
+		} catch (error) {
+			if (isNotFound(error)) return null;
+			throw error;
+		}
+	}
+	async #listPullRequests(input) {
+		requireGithubConnection(input.connection);
+		const page = parsePositiveCursor(input.cursor);
+		const query = new URLSearchParams({
+			state: input.state ?? "open",
+			page: String(page),
+			per_page: String(PAGE_SIZE)
+		});
+		const result = await this.#client.request("GET", `${repositoryPath(input.sourceId, "pulls")}?${query}`);
+		return {
+			pullRequests: result.pullRequests.filter((pullRequest) => input.includeDrafts !== false || !pullRequest.draft).map(parsePullRequest),
+			nextCursor: result.pullRequests.length === PAGE_SIZE ? String(page + 1) : null
+		};
+	}
+	async #getPullRequest(input) {
+		try {
+			return parsePullRequest(await this.#client.request("GET", pullRequestPath(input, input.pullRequestId)));
+		} catch (error) {
+			if (isNotFound(error)) return null;
+			throw error;
+		}
+	}
+	async #createPullRequest(input) {
+		requireGithubConnection(input.connection);
+		return parsePullRequest(await this.#client.request("POST", repositoryPath(input.sourceId, "pulls"), {
+			head: input.headBranch,
+			base: input.baseBranch,
+			title: input.title,
+			body: input.body,
+			draft: input.draft
+		}, { actingUserId: input.actingUserId }));
+	}
+	async #updatePullRequest(input) {
+		return parsePullRequest(await this.#client.request("PATCH", pullRequestPath(input, input.pullRequestId), {
+			title: input.title,
+			body: input.body === null ? "" : input.body,
+			base: input.baseBranch,
+			state: input.state
+		}, { actingUserId: input.actingUserId }));
+	}
+	#mergePullRequest(input) {
+		return this.#client.request("PUT", `${pullRequestPath(input, input.pullRequestId)}/merge`, {
+			commitTitle: input.commitTitle,
+			commitMessage: input.commitMessage,
+			method: input.method
+		}, { actingUserId: input.actingUserId });
+	}
+	async #listComments(input) {
+		const page = parsePositiveCursor(input.cursor);
+		const result = await this.#client.request("GET", `${repositoryPath(input.sourceId, `issues/${requirePositiveId(input.pullRequestId, "pull request")}/comments`)}?page=${page}&per_page=${PAGE_SIZE}`);
+		return {
+			comments: result.comments.map(parseComment),
+			nextCursor: result.comments.length === PAGE_SIZE ? String(page + 1) : null
+		};
+	}
+	async #createComment(input) {
+		return parseComment(await this.#client.request("POST", repositoryPath(input.sourceId, `issues/${requirePositiveId(input.pullRequestId, "pull request")}/comments`), { body: input.body }, { actingUserId: input.actingUserId }));
+	}
+	async #updateComment(input) {
+		requireGithubConnection(input.connection);
+		return parseComment(await this.#client.request("PATCH", repositoryPath(input.sourceId, `issues/comments/${requirePositiveId(input.commentId, "comment")}`), { body: input.body }, { actingUserId: input.actingUserId }));
+	}
+	async #deleteComment(input) {
+		requireGithubConnection(input.connection);
+		await this.#client.request("DELETE", repositoryPath(input.sourceId, `issues/comments/${requirePositiveId(input.commentId, "comment")}`), void 0, { actingUserId: input.actingUserId });
+	}
+	async #listReviews(input) {
+		const page = parsePositiveCursor(input.cursor);
+		const result = await this.#client.request("GET", `${pullRequestPath(input, input.pullRequestId)}/reviews?page=${page}&per_page=${PAGE_SIZE}`);
+		return {
+			reviews: result.reviews.map(parseReview),
+			nextCursor: result.reviews.length === PAGE_SIZE ? String(page + 1) : null
+		};
+	}
+	async #getReview(input) {
+		try {
+			return parseReview(await this.#client.request("GET", `${pullRequestPath(input, input.pullRequestId)}/reviews/${requirePositiveId(input.reviewId, "review")}`));
+		} catch (error) {
+			if (isNotFound(error)) return null;
+			throw error;
+		}
+	}
+	async #createReview(input) {
+		return parseReview(await this.#client.request("POST", `${pullRequestPath(input, input.pullRequestId)}/reviews`, {
+			body: input.body,
+			commitId: input.commitId,
+			event: input.event ? reviewEvent(input.event) : void 0
+		}, { actingUserId: input.actingUserId }));
+	}
+	async #updateReview(input) {
+		return parseReview(await this.#client.request("PUT", `${pullRequestPath(input, input.pullRequestId)}/reviews/${requirePositiveId(input.reviewId, "review")}`, { body: input.body }, { actingUserId: input.actingUserId }));
+	}
+	async #submitReview(input) {
+		return parseReview(await this.#client.request("POST", `${pullRequestPath(input, input.pullRequestId)}/reviews/${requirePositiveId(input.reviewId, "review")}/events`, {
+			body: input.body,
+			event: reviewEvent(input.event)
+		}, { actingUserId: input.actingUserId }));
+	}
+	async #dismissReview(input) {
+		return parseReview(await this.#client.request("PUT", `${pullRequestPath(input, input.pullRequestId)}/reviews/${requirePositiveId(input.reviewId, "review")}/dismissals`, { message: input.message }, { actingUserId: input.actingUserId }));
+	}
+	async #deletePendingReview(input) {
+		await this.#client.request("DELETE", `${pullRequestPath(input, input.pullRequestId)}/reviews/${requirePositiveId(input.reviewId, "review")}`, void 0, { actingUserId: input.actingUserId });
+	}
+	async #listReviewComments(input) {
+		const page = parsePositiveCursor(input.cursor);
+		const result = await this.#client.request("GET", `${pullRequestPath(input, input.pullRequestId)}/comments?page=${page}&per_page=${PAGE_SIZE}`);
+		return {
+			comments: result.comments.map(parseReviewComment),
+			nextCursor: result.comments.length === PAGE_SIZE ? String(page + 1) : null
+		};
+	}
+	async #createReviewComment(input) {
+		let body;
+		if (input.replyToId !== void 0) body = {
+			body: input.body,
+			replyToId: requirePositiveId(input.replyToId, "review comment")
+		};
+		else {
+			if (!input.commitId || !input.path || input.line === void 0 || !input.side) throw new Error("A review comment requires commitId, path, line, and side unless it is a reply.");
+			body = {
+				body: input.body,
+				commitId: input.commitId,
+				path: input.path,
+				line: input.line,
+				side: input.side.toUpperCase(),
+				startLine: input.startLine,
+				startSide: input.startSide?.toUpperCase()
+			};
+		}
+		return parseReviewComment(await this.#client.request("POST", `${pullRequestPath(input, input.pullRequestId)}/comments`, body, { actingUserId: input.actingUserId }));
+	}
+	async #updateReviewComment(input) {
+		requireGithubConnection(input.connection);
+		return parseReviewComment(await this.#client.request("PATCH", repositoryPath(input.sourceId, `pulls/comments/${requirePositiveId(input.commentId, "review comment")}`), { body: input.body }, { actingUserId: input.actingUserId }));
+	}
+	async #deleteReviewComment(input) {
+		requireGithubConnection(input.connection);
+		await this.#client.request("DELETE", repositoryPath(input.sourceId, `pulls/comments/${requirePositiveId(input.commentId, "review comment")}`), void 0, { actingUserId: input.actingUserId });
+	}
+	#requestedReviewers(method, input) {
+		requireGithubConnection(input.connection);
+		return this.#client.request(method, `${pullRequestPath(input, input.pullRequestId)}/requested-reviewers`, method === "GET" ? void 0 : {
+			users: input.users,
+			teams: input.teams
+		}, method === "GET" ? void 0 : { actingUserId: input.actingUserId });
+	}
+};
+function repositoryPath(sourceId, suffix) {
+	const { owner, repo } = splitRepository(sourceId);
+	return `${API_PREFIX}/github/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/${suffix}`;
+}
+function pullRequestPath(input, pullRequestId) {
+	requireGithubConnection(input.connection);
+	return repositoryPath(input.sourceId, `pulls/${requirePositiveId(pullRequestId, "pull request")}`);
+}
+function splitRepository(sourceId) {
+	const slash = sourceId.indexOf("/");
+	if (slash <= 0 || slash === sourceId.length - 1) throw new Error("GitHub capabilities require an owner/repository source.");
+	return {
+		owner: sourceId.slice(0, slash),
+		repo: sourceId.slice(slash + 1)
+	};
+}
+function parseIntakeIssue(sourceId, issue) {
+	return {
+		id: String(issue.number),
+		identifier: `#${issue.number}`,
+		title: issue.title,
+		url: issue.htmlUrl,
+		author: issue.user?.login ?? null,
+		state: issue.state,
+		stateType: issue.state,
+		priority: null,
+		assignee: issue.assignees[0] ?? null,
+		source: sourceId,
+		labels: issue.labels,
+		commentCount: issue.commentCount,
+		createdAt: issue.createdAt,
+		updatedAt: issue.updatedAt
+	};
+}
+function parseIntakeIssueDetail(sourceId, issue, comments) {
+	return {
+		...parseIntakeIssue(sourceId, issue),
+		description: issue.body?.trim() ? issue.body : null,
+		comments: comments.map((comment) => ({
+			author: comment.user?.login ?? null,
+			body: comment.body,
+			createdAt: comment.createdAt
+		}))
+	};
+}
+function parsePullRequest(pullRequest) {
+	return {
+		id: String(pullRequest.number),
+		title: pullRequest.title,
+		url: pullRequest.htmlUrl,
+		author: pullRequest.user?.login ?? null,
+		body: pullRequest.body?.trim() ? pullRequest.body : null,
+		state: pullRequest.state,
+		draft: pullRequest.draft,
+		merged: pullRequest.merged,
+		mergeable: pullRequest.mergeable,
+		baseBranch: pullRequest.base.ref,
+		headBranch: pullRequest.head.ref,
+		headSha: pullRequest.head.sha,
+		createdAt: pullRequest.createdAt,
+		updatedAt: pullRequest.updatedAt
+	};
+}
+function parseComment(comment) {
+	return {
+		id: String(comment.id),
+		url: comment.htmlUrl,
+		author: comment.user?.login ?? null,
+		body: comment.body,
+		createdAt: comment.createdAt,
+		updatedAt: comment.updatedAt
+	};
+}
+function parseReview(review) {
+	return {
+		id: String(review.id),
+		url: review.htmlUrl,
+		author: review.user?.login ?? null,
+		body: review.body?.trim() ? review.body : null,
+		state: {
+			PENDING: "pending",
+			COMMENTED: "commented",
+			APPROVED: "approved",
+			CHANGES_REQUESTED: "changes-requested",
+			DISMISSED: "dismissed"
+		}[review.state],
+		commitId: review.commitId,
+		submittedAt: review.submittedAt
+	};
+}
+function parseReviewComment(comment) {
+	return {
+		...parseComment(comment),
+		path: comment.path,
+		line: comment.line,
+		side: comment.side?.toLowerCase(),
+		commitId: comment.commitId,
+		replyToId: comment.replyToId === null ? null : String(comment.replyToId)
+	};
+}
+function requireGithubConnection(connection) {
+	if (connection.type !== "app-installation" && connection.type !== "oauth") throw new Error("GitHub capabilities require a GitHub connection.");
+}
+function requireSingleSource(sourceIds, message) {
+	if (sourceIds.length !== 1) throw new Error(message);
+	return sourceIds[0];
+}
+function requireSource(sourceId, message) {
+	if (!sourceId) throw new Error(message);
+	return sourceId;
+}
+function normalizeLabels(labels) {
+	return [...new Set((labels ?? []).map((label) => label.trim()).filter(Boolean))];
+}
+function parsePositiveCursor(cursor) {
+	if (cursor === void 0) return 1;
+	const parsed = parsePositiveInteger(cursor);
+	if (parsed === null) throw new Error("GitHub cursor must be a positive page number.");
+	return parsed;
+}
+function parsePositiveInteger(value) {
+	if (!/^\d+$/.test(value)) return null;
+	const parsed = Number(value);
+	return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function parseGithubExternalTarget(externalId) {
+	const match = externalId.match(/^(.+\/.+):(\d+)$/) ?? externalId.match(/^github:(\d+):(?:issue|pull-request):(\d+)$/) ?? externalId.match(/^(\d+):(\d+)$/);
+	if (!match?.[1] || !match[2] || parsePositiveInteger(match[2]) === null) return null;
+	return {
+		repository: match[1],
+		issueId: match[2]
+	};
+}
+function optionalPositiveIntegerEnv(name) {
+	const value = process.env[name]?.trim();
+	if (!value) return void 0;
+	const parsed = parsePositiveInteger(value);
+	if (parsed === null) throw new Error(`${name} must be a positive integer.`);
+	return parsed;
+}
+function requirePositiveId(value, resource) {
+	const parsed = parsePositiveInteger(value);
+	if (parsed === null) throw new Error(`GitHub ${resource} id must be a positive integer.`);
+	return parsed;
+}
+function reviewEvent(event) {
+	if (event === "approve") return "APPROVE";
+	if (event === "request-changes") return "REQUEST_CHANGES";
+	return "COMMENT";
+}
+function isNotFound(error) {
+	return error instanceof PlatformApiError && error.status === 404;
+}
+//#endregion
+export { PlatformGithubIntegration };
+
+//# sourceMappingURL=integration.js.map