forges 0.0.0 → 0.1.0

package/dist/cursor-origin-BhqYx2oW.mjs

@@ -0,0 +1,980 @@
+import { E as summariseChecks, Nt as soleMergeMethod, O as toDate, Pt as toMergeError, S as phased, T as resolveToken, _t as ForgeError, c as checkRunState, d as forgeIterable, dt as fromBase64, f as getManyConcurrently, ft as toFileContent, g as iteratePages, j as toWarning, jt as UnsupportedOperationError, k as toFileStatus, n as perKind, r as verb, rt as createFetcher, t as defineForgeProvider, v as memo, w as requireThread } from "./define-D3yEXtKK.mjs";
+import { a as sha256Hex, n as headerValue, o as signEdDsaJwt, t as bodyText, u as verifyEd25519 } from "./crypto-CQNEyYHD.mjs";
+import { i as refEvent } from "./webhooks-rn9-8lxT.mjs";
+//#region src/cursor-origin/auth.ts
+/** Origin caps installation tokens at the lifetime of the JWT that minted them. */
+const JWT_LIFETIME_SECONDS = 300;
+const REFRESH_MARGIN_MS = 6e4;
+function createOriginAppCredentials(auth, createFetcher) {
+	let jwt;
+	const tokens = /* @__PURE__ */ new Map();
+	const appId = String(auth.appId);
+	async function appJwt() {
+		if (jwt && jwt.expiresAt > Date.now() + REFRESH_MARGIN_MS) return jwt.value;
+		const now = Math.floor(Date.now() / 1e3);
+		const value = await signEdDsaJwt(auth.privateKey, {
+			iss: appId,
+			aud: "origin-apps",
+			iat: now,
+			exp: now + JWT_LIFETIME_SECONDS
+		}, appId);
+		jwt = {
+			value,
+			expiresAt: (now + JWT_LIFETIME_SECONDS) * 1e3
+		};
+		return value;
+	}
+	const fetcher = createFetcher(async () => ({ authorization: `Bearer ${await appJwt()}` }));
+	async function installationTokenDetails(installationId, options) {
+		const cached = tokens.get(installationId);
+		if (cached && cached.expiresAt.getTime() > Date.now() + REFRESH_MARGIN_MS) return cached;
+		const { data } = await fetcher.json(`/app/installations/${installationId}/access_tokens`, {
+			method: "POST",
+			json: {},
+			signal: options?.signal
+		});
+		const token = {
+			token: data.token,
+			expiresAt: new Date(data.expiresAt),
+			permissions: {}
+		};
+		tokens.set(installationId, token);
+		return token;
+	}
+	return {
+		appJwt,
+		installationTokenDetails,
+		installationToken: async (installationId, options) => (await installationTokenDetails(installationId, options)).token
+	};
+}
+//#endregion
+//#region src/cursor-origin/normalise.ts
+const FORGE = "cursor-origin";
+function toActor(instance, actor) {
+	if (actor?.user) {
+		const user = actor.user;
+		return {
+			forge: FORGE,
+			instance,
+			login: user.handle ?? user.email ?? user.id,
+			id: user.id,
+			name: user.displayName,
+			typeRaw: user.performedVia?.app ? "user_via_app" : "user",
+			isBotHint: Boolean(user.performedVia?.app)
+		};
+	}
+	if (actor?.app) return {
+		forge: FORGE,
+		instance,
+		login: actor.app.displayName ?? actor.app.id,
+		id: actor.app.id,
+		name: actor.app.displayName,
+		typeRaw: "app",
+		isBotHint: true
+	};
+	if (actor?.serviceAccount) return {
+		forge: FORGE,
+		instance,
+		login: actor.serviceAccount.id,
+		id: actor.serviceAccount.id,
+		typeRaw: "service_account",
+		isBotHint: true
+	};
+}
+function toRepoRef(instance, repo) {
+	return {
+		forge: FORGE,
+		instance,
+		owner: repo.owner.slug,
+		name: repo.name,
+		externalId: repo.id
+	};
+}
+function toRepo(instance, raw) {
+	return {
+		ref: toRepoRef(instance, raw),
+		defaultBranch: raw.defaultBranch,
+		visibility: raw.visibility ?? "private",
+		visibilityRaw: raw.visibility,
+		isFork: false,
+		isArchived: false,
+		topics: [],
+		cloneUrls: raw.cloneUrl ? { https: raw.cloneUrl } : void 0,
+		createdAt: toDate(raw.createdAt),
+		updatedAt: toDate(raw.updatedAt),
+		pushedAt: toDate(raw.pushedAt),
+		raw
+	};
+}
+function threadState(raw) {
+	return raw.merged ? "merged" : raw.state === "open" ? "open" : raw.state === "closed" ? "closed" : "unknown";
+}
+function toThread(ref, raw) {
+	const parent = raw.stack?.parentPullRequest;
+	return {
+		ref: {
+			...ref,
+			kind: "pull_request",
+			number: raw.number,
+			externalId: raw.id
+		},
+		kind: "pull_request",
+		title: raw.title,
+		body: raw.body || void 0,
+		state: threadState(raw),
+		stateRaw: raw.merged ? "merged" : raw.state,
+		isDraft: raw.draft ?? false,
+		author: toActor(ref.instance, raw.author),
+		assignees: [],
+		reviewers: [],
+		labels: (raw.labels ?? []).map((label) => ({
+			name: label.name,
+			colour: label.color,
+			description: label.description || void 0
+		})),
+		createdAt: toDate(raw.createdAt),
+		updatedAt: toDate(raw.updatedAt),
+		closedAt: toDate(raw.closedAt),
+		lastActivityAt: toDate(raw.updatedAt),
+		branches: raw.head && raw.base ? {
+			head: {
+				ref: raw.head.ref,
+				sha: raw.head.sha
+			},
+			base: {
+				ref: raw.base.ref,
+				sha: raw.base.sha
+			},
+			mergeCommitSha: raw.mergeCommitSha
+		} : void 0,
+		...raw.stack ? { stack: {
+			id: raw.stack.id,
+			...parent ? { parent: {
+				forge: FORGE,
+				instance: ref.instance,
+				repo: ref.repo,
+				kind: "pull_request",
+				number: parent.number,
+				externalId: parent.id
+			} } : {}
+		} } : {},
+		raw
+	};
+}
+/** General-discussion comments have no diff anchor; anchored ones are review comments. */
+function isConversationComment(raw) {
+	return !raw.thread?.path;
+}
+function toComment(thread, raw) {
+	return {
+		ref: {
+			forge: FORGE,
+			instance: thread.instance,
+			thread,
+			id: raw.id
+		},
+		body: raw.body,
+		author: toActor(thread.instance, raw.author),
+		createdAt: toDate(raw.createdAt),
+		updatedAt: toDate(raw.updatedAt),
+		raw
+	};
+}
+function toCommentEvent(thread, raw) {
+	const anchored = !isConversationComment(raw);
+	const actor = toActor(thread.instance, raw.author);
+	return {
+		forge: FORGE,
+		instance: thread.instance,
+		id: raw.id,
+		kind: anchored ? "review_comment" : "comment",
+		kindRaw: anchored ? "pull_request.review_comment" : "pull_request.comment",
+		summary: `${actor?.login ?? "someone"} ${anchored ? `commented on ${raw.thread.path}` : "commented"}`,
+		occurredAt: toDate(raw.createdAt) ?? /* @__PURE__ */ new Date(0),
+		actor,
+		repo: thread.repo,
+		thread,
+		source: "poll",
+		payload: raw
+	};
+}
+const VERDICTS = {
+	approve: "approved",
+	request_changes: "changes_requested",
+	comment: "commented"
+};
+function toReviewEvent(thread, raw, source = "poll") {
+	const actor = toActor(thread.instance, raw.author);
+	return {
+		forge: FORGE,
+		instance: thread.instance,
+		id: raw.id,
+		kind: "review",
+		kindRaw: raw.dismissal ? "pull_request.review.dismissed" : `pull_request.review.${raw.verdict}`,
+		summary: `${actor?.login ?? "someone"} ${raw.dismissal ? "dismissed a review" : `reviewed (${VERDICTS[raw.verdict] ?? raw.verdict})`}`,
+		occurredAt: toDate(raw.submittedAt) ?? /* @__PURE__ */ new Date(0),
+		actor,
+		repo: thread.repo,
+		thread,
+		source,
+		payload: raw
+	};
+}
+function toCheck(repo, raw) {
+	return {
+		ref: {
+			forge: FORGE,
+			instance: repo.instance,
+			repo,
+			id: raw.id,
+			type: "check_run"
+		},
+		name: raw.name,
+		state: checkRunState(raw.status, raw.conclusion),
+		stateRaw: raw.status,
+		conclusionRaw: raw.conclusion,
+		url: raw.detailsUrl,
+		startedAt: toDate(raw.startedAt),
+		completedAt: toDate(raw.completedAt),
+		raw
+	};
+}
+function toReview(thread, raw) {
+	return {
+		ref: {
+			forge: FORGE,
+			instance: thread.instance,
+			thread,
+			id: raw.id
+		},
+		author: toActor(thread.instance, raw.author),
+		state: raw.dismissal ? "dismissed" : VERDICTS[raw.verdict] ?? "unknown",
+		stateRaw: raw.verdict,
+		body: raw.body || void 0,
+		submittedAt: toDate(raw.submittedAt),
+		comments: false,
+		raw
+	};
+}
+function toChangedFile(raw) {
+	return {
+		path: raw.filename,
+		previousPath: raw.previousFilename,
+		status: toFileStatus(raw.status),
+		statusRaw: raw.status,
+		additions: raw.additions,
+		deletions: raw.deletions,
+		patch: raw.patch
+	};
+}
+function toCommit(repo, raw, files) {
+	return {
+		ref: {
+			forge: FORGE,
+			instance: repo.instance,
+			repo,
+			sha: raw.sha
+		},
+		sha: raw.sha,
+		message: raw.commit?.message ?? "",
+		author: {
+			name: raw.commit?.author?.name,
+			email: raw.commit?.author?.email,
+			date: toDate(raw.commit?.author?.date)
+		},
+		committer: {
+			name: raw.commit?.committer?.name,
+			email: raw.commit?.committer?.email,
+			date: toDate(raw.commit?.committer?.date)
+		},
+		parents: raw.parents?.flatMap((parent) => parent.sha ? [parent.sha] : []) ?? [],
+		...raw.stats ? { stats: {
+			additions: raw.stats.additions ?? 0,
+			deletions: raw.stats.deletions ?? 0,
+			total: raw.stats.total
+		} } : {},
+		...files ? { files } : {},
+		raw
+	};
+}
+function toBranch(raw) {
+	return {
+		name: raw.name,
+		sha: raw.commit?.sha ?? "",
+		raw
+	};
+}
+/** Origin lists tags as refs, so the name is the ref minus its `refs/tags/` prefix. */
+function toTag(raw) {
+	return {
+		name: raw.ref.replace(/^refs\/tags\//, ""),
+		sha: raw.object?.sha ?? "",
+		raw
+	};
+}
+function toTreeEntry(raw) {
+	return {
+		path: raw.path,
+		type: raw.mode === "120000" ? "symlink" : raw.type === "tree" ? "directory" : raw.type === "commit" ? "submodule" : "file",
+		sha: raw.sha,
+		size: raw.size,
+		mode: raw.mode
+	};
+}
+//#endregion
+//#region src/cursor-origin/webhooks.ts
+/** Deliveries older or newer than this are refused, as Origin documents. */
+const TOLERANCE_SECONDS = 300;
+const KEYS_TTL_MS = 6e5;
+/**
+* Verifies a delivery: an Ed25519 signature (`v1ed,<base64>`) over the UTF-8
+* hex SHA-256 of `<webhook-id>.<webhook-timestamp>.<body>`, against any
+* active key. Origin signatures carry no key id.
+*/
+async function verifyOriginSignature(delivery, keys, now = Date.now()) {
+	const id = headerValue(delivery.headers, "webhook-id");
+	const timestamp = Number(headerValue(delivery.headers, "webhook-timestamp"));
+	const signature = headerValue(delivery.headers, "webhook-signature")?.split(/\s+/).find((value) => value.startsWith("v1ed,"));
+	if (!id || !signature || !Number.isInteger(timestamp) || Math.abs(Math.floor(now / 1e3) - timestamp) > TOLERANCE_SECONDS) return false;
+	const digest = await sha256Hex(`${id}.${timestamp}.${bodyText(delivery.body)}`);
+	for (const key of await keys()) if (await verifyEd25519(key, digest, signature.slice(5))) return true;
+	return false;
+}
+const PULL_KINDS = {
+	"pull_request.created": "state_change",
+	"pull_request.published": "state_change",
+	"pull_request.reopened": "state_change",
+	"pull_request.closed": "state_change",
+	"pull_request.merged": "state_change",
+	"pull_request.comment.created": "comment",
+	"pull_request.comment.reaction.added": "reaction",
+	"pull_request.comment.reaction.removed": "reaction",
+	"pull_request.label.added": "label",
+	"pull_request.label.removed": "label",
+	"pull_request.reviewer.added": "assignment",
+	"pull_request.reviewer.removed": "assignment",
+	"pull_request.reviewer.rerequested": "assignment",
+	"pull_request.head_ref.pushed": "commit"
+};
+function translateOriginWebhook(instance, delivery) {
+	const envelope = JSON.parse(bodyText(delivery.body));
+	const { event } = envelope;
+	const payload = event.payload ?? {};
+	const repo = payload.repository ? toRepoRef(instance, payload.repository) : void 0;
+	const pull = payload.pullRequest;
+	const thread = pull && repo ? {
+		forge: FORGE,
+		instance,
+		repo,
+		kind: "pull_request",
+		number: pull.number,
+		externalId: pull.id
+	} : void 0;
+	const base = {
+		forge: FORGE,
+		instance,
+		id: envelope.deliveryId ?? event.id,
+		kindRaw: event.type,
+		occurredAt: toDate(event.eventTime) ?? /* @__PURE__ */ new Date(),
+		repo,
+		thread,
+		installationId: envelope.installationId,
+		source: "webhook",
+		payload: envelope
+	};
+	if (event.type.startsWith("pull_request.review.") && payload.review && thread) return [{
+		...toReviewEvent(thread, payload.review, "webhook"),
+		...base
+	}];
+	if (thread) {
+		const actor = toActor(instance, payload.comment?.author ?? payload.actor ?? payload.createdBy ?? pull?.author);
+		const kind = payload.comment?.thread?.path ? "review_comment" : PULL_KINDS[event.type] ?? "other";
+		return [{
+			...base,
+			kind,
+			actor,
+			summary: `${actor?.login ?? "someone"}: ${event.type.replace(/^pull_request\./, "").replaceAll(".", " ")} on #${thread.number}`
+		}];
+	}
+	if (event.type === "repository.pushed") {
+		const pusher = toActor(instance, payload.pusher);
+		const who = pusher?.login ?? "someone";
+		return (payload.refUpdates ?? []).map((update, index) => {
+			const event = refEvent(who, {
+				ref: update.ref,
+				before: update.before,
+				after: update.after,
+				created: update.created,
+				deleted: update.deleted,
+				forced: update.forced,
+				commits: update.headCommit?.sha ? [{
+					sha: update.headCommit.sha,
+					message: update.headCommit.message ?? ""
+				}] : []
+			});
+			return {
+				...base,
+				id: `${base.id}:${index}`,
+				actor: pusher,
+				...event,
+				...event.kind === "push" ? { summary: `${who} pushed to ${update.ref.replace(/^refs\/(?:heads|tags)\//, "")}` } : {}
+			};
+		});
+	}
+	if (event.type.startsWith("installation.")) return [{
+		...base,
+		kind: "installation",
+		installationId: payload.installation?.id ?? envelope.installationId,
+		detail: {
+			type: "installation",
+			actionRaw: event.type,
+			installationId: payload.installation?.id ?? envelope.installationId,
+			added: (payload.installation?.repositories ?? []).map((reference) => toRepoRef(instance, reference)),
+			removed: []
+		},
+		summary: `Installation ${event.type.slice(13)}`
+	}];
+	return [{
+		...base,
+		kind: "other",
+		summary: event.type
+	}];
+}
+const ORIGIN_WEBHOOK_EVENTS = [
+	{
+		kind: "comment",
+		action: "created"
+	},
+	{
+		kind: "review",
+		action: "submitted"
+	},
+	{
+		kind: "state_change",
+		action: "opened"
+	},
+	{
+		kind: "state_change",
+		action: "closed"
+	},
+	{
+		kind: "state_change",
+		action: "merged"
+	},
+	{ kind: "installation" }
+];
+const cursorOriginWebhooks = ({ instance, baseUrl, createFetcher }) => {
+	const keysFetcher = createFetcher({ baseUrl });
+	const signingKeys = memo(async () => (await keysFetcher.json("/keys")).data.keys ?? [], KEYS_TTL_MS);
+	return {
+		events: ORIGIN_WEBHOOK_EVENTS,
+		verify: (delivery) => verifyOriginSignature(delivery, signingKeys),
+		translate: (delivery) => translateOriginWebhook(instance, delivery)
+	};
+};
+//#endregion
+//#region src/cursor-origin/index.ts
+/** The Origin API version this provider was built against. See `docs/content/4.providers/cursor-origin.md`. */
+const ORIGIN_API_VERSION = "v1alpha1";
+const PULL = { pull_request: "experimental" };
+const UNVERIFIED = { pull_request: "unverified" };
+const PAGE_SIZE = 50;
+function installationId(installation) {
+	return typeof installation === "string" ? installation : installation.id;
+}
+function setupOrigin({ options, baseUrl, instance, origin: context, fetcher, createFetcher, derive, state: credentials }) {
+	const repoPath = (repo) => `/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.name)}`;
+	const pullPath = (ref) => `${repoPath(ref.repo)}/pulls/${ref.number}`;
+	async function tokenPage(path, field, listOptions, from = fetcher) {
+		const { data } = await from.json(path, {
+			query: {
+				...listOptions.query,
+				pageSize: Math.min(listOptions.perPage ?? PAGE_SIZE, 100),
+				pageToken: listOptions.cursor?.token
+			},
+			signal: listOptions.signal
+		});
+		const next = data.nextPageToken;
+		return {
+			items: data[field] ?? [],
+			cursor: next ? { token: next } : void 0
+		};
+	}
+	function all(path, field, options = {}) {
+		return Array.fromAsync(iteratePages((page) => tokenPage(path, field, {
+			...page,
+			signal: options.signal
+		})));
+	}
+	async function headChecks(repo, sha, signal) {
+		return (await all(`${repoPath(repo)}/commits/${sha}/check-runs`, "checkRuns", { signal })).map((raw) => toCheck(repo, raw));
+	}
+	async function get(thread, options) {
+		const ref = requireThread(thread, context);
+		const { data } = await fetcher.json(pullPath(ref), { signal: options?.signal });
+		const result = toThread(ref, data);
+		const sha = data.version?.headSha ?? data.head?.sha;
+		if (sha) try {
+			result.checks = summariseChecks((await headChecks(ref.repo, sha, options?.signal)).map((check) => check.state));
+		} catch (error) {
+			if (!(error instanceof ForgeError)) throw error;
+			result.warnings = [...result.warnings ?? [], toWarning("checks_unreadable", error, ref.number)];
+		}
+		return result;
+	}
+	const VERDICTS = {
+		approve: "approve",
+		request_changes: "request_changes",
+		comment: "comment"
+	};
+	async function createReview(thread, input, options) {
+		const ref = requireThread(thread, context);
+		if (!input.event) throw new UnsupportedOperationError("Cursor Origin has no pending reviews; pass an event", context);
+		if (input.comments?.length) throw new UnsupportedOperationError("Cursor Origin takes inline comments as their own requests, not with a review", context);
+		const { data } = await fetcher.json(`${pullPath(ref)}/reviews`, {
+			method: "POST",
+			json: {
+				verdict: VERDICTS[input.event],
+				body: input.body ?? ""
+			},
+			signal: options?.signal
+		});
+		return toReview(ref, data);
+	}
+	async function setThreadResolved(id, resolved, options) {
+		await fetcher.raw(`/pulls/threads/${encodeURIComponent(id)}`, {
+			method: "PATCH",
+			json: { resolved },
+			signal: options?.signal
+		});
+	}
+	async function listPage(repo, query = {}) {
+		if (query.kind === "issue" || query.kind === "discussion") return {
+			items: [],
+			warnings: [{
+				code: "kind_unsupported",
+				message: `Cursor Origin has pull requests only, no ${query.kind}s`
+			}]
+		};
+		const warnings = [];
+		if (!query.cursor) {
+			if (query.labels?.length || query.assignee) warnings.push({
+				code: "filter_unsupported",
+				message: "Cursor Origin cannot filter pull requests by label or assignee; those filters were ignored"
+			});
+			if (query.sort === "comments") warnings.push({
+				code: "sort_unsupported",
+				message: "Cursor Origin cannot sort by comment count; sorted by creation time"
+			});
+		}
+		const page = await tokenPage(`${repoPath(repo)}/pulls`, "pullRequests", {
+			...query,
+			query: {
+				state: query.state === "merged" ? "closed" : query.state ?? "open",
+				author: query.author,
+				sortBy: query.sort === "updated" ? "updated" : "created",
+				direction: query.direction ?? "desc",
+				since: query.createdAfter?.toISOString()
+			}
+		});
+		const since = query.since?.getTime();
+		return {
+			items: page.items.map((raw) => toThread({
+				forge: FORGE,
+				instance,
+				repo,
+				kind: "pull_request",
+				number: raw.number
+			}, raw)).filter((thread) => (since === void 0 || (thread.updatedAt?.getTime() ?? 0) >= since) && (query.state !== "merged" || thread.state === "merged")),
+			cursor: page.cursor,
+			...warnings.length ? { warnings } : {}
+		};
+	}
+	async function commentsPage(thread, listOptions = {}) {
+		const ref = requireThread(thread, context);
+		const page = await tokenPage(`${pullPath(ref)}/comments`, "comments", listOptions);
+		return {
+			items: page.items.filter(isConversationComment).map((raw) => toComment(ref, raw)),
+			cursor: page.cursor
+		};
+	}
+	async function eventsPage(thread, listOptions = {}) {
+		const ref = requireThread(thread, context);
+		const [comments, reviews] = await Promise.all([all(`${pullPath(ref)}/comments`, "comments", listOptions), all(`${pullPath(ref)}/reviews`, "reviews", listOptions)]);
+		return { items: [...comments.map((raw) => toCommentEvent(ref, raw)), ...reviews.filter((review) => review.submittedAt).map((raw) => toReviewEvent(ref, raw))].sort((a, b) => a.occurredAt.getTime() - b.occurredAt.getTime()) };
+	}
+	async function reposPage(listOptions = {}, from = fetcher) {
+		const page = await tokenPage("/installation/repos", "repositories", listOptions, from);
+		return {
+			items: page.items.map((raw) => toRepo(instance, raw)),
+			cursor: page.cursor
+		};
+	}
+	/** A user token has no single repository listing, so each namespace the user belongs to is listed in turn. */
+	async function userReposPage(listOptions = {}) {
+		const namespaces = await all("/namespaces", "namespaces", listOptions);
+		if (!namespaces.length) return { items: [] };
+		return phased(namespaces.map((namespace) => async (cursor) => {
+			const page = await tokenPage(`/repos/${encodeURIComponent(namespace.slug)}`, "repositories", {
+				...listOptions,
+				cursor
+			});
+			return {
+				items: page.items.map((raw) => toRepo(instance, raw)),
+				cursor: page.cursor
+			};
+		}), listOptions.cursor);
+	}
+	function createInstallationsApi(app) {
+		const appFetcher = createFetcher({
+			baseUrl,
+			authHeaders: async () => ({ authorization: `Bearer ${await app.appJwt()}` })
+		});
+		const auth = options.auth;
+		const toInstallation = (raw) => ({
+			forge: FORGE,
+			instance,
+			id: raw.id,
+			targetTypeRaw: raw.target?.type,
+			repositorySelectionRaw: raw.repoSelectionMode,
+			...raw.target ? { account: {
+				forge: FORGE,
+				instance,
+				login: raw.target.slug,
+				id: raw.target.id ?? raw.target.slug,
+				typeRaw: raw.target.type,
+				isBotHint: false
+			} } : {},
+			raw
+		});
+		const provider = (installation) => derive({
+			...options,
+			auth: {
+				...auth,
+				installationId: installationId(installation)
+			}
+		}, app);
+		const listPage = async (listOptions = {}) => {
+			const page = await tokenPage("/app/installations", "installations", listOptions, appFetcher);
+			return {
+				items: page.items.map(toInstallation),
+				cursor: page.cursor
+			};
+		};
+		return {
+			listPage,
+			get: async (installation, options) => toInstallation((await appFetcher.json(`/app/installations/${installationId(installation)}`, { signal: options?.signal })).data),
+			token: (installation, options) => app.installationTokenDetails(installationId(installation), options),
+			reposPage(installation, listOptions) {
+				const id = installationId(installation);
+				return reposPage(listOptions, createFetcher({
+					baseUrl,
+					authHeaders: async () => ({ authorization: `Bearer ${await app.installationToken(id)}` })
+				}));
+			},
+			provider,
+			providers: () => forgeIterable(async function* () {
+				for await (const installation of iteratePages(listPage)) yield {
+					installation,
+					provider: provider(installation)
+				};
+			})
+		};
+	}
+	const auth = options.auth;
+	const repoAccess = auth?.type === "token" || auth?.type === "app" && auth.installationId !== void 0;
+	return {
+		checks: { list: verb("unverified", async (repo, sha, options) => ({ items: await headChecks(repo, sha, options?.signal) })) },
+		contents: {
+			file: verb("unverified", async (repo, path, fileOptions = {}) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/contents`, {
+					query: {
+						path,
+						ref: fileOptions.ref
+					},
+					signal: fileOptions.signal
+				});
+				const file = {
+					path: data.path,
+					sha: data.sha,
+					size: data.size === void 0 ? void 0 : Number(data.size)
+				};
+				const content = data.content ?? (data.sha ? (await fetcher.json(`${repoPath(repo)}/git/blobs/${data.sha}`, { signal: fileOptions.signal })).data.content : "");
+				return toFileContent(fromBase64(content), file, fileOptions, context);
+			}),
+			treePage: verb("unverified", async (repo, treeOptions = {}) => {
+				const ref = treeOptions.ref ?? "HEAD";
+				const { data } = await fetcher.json(`${repoPath(repo)}/git/trees/${encodeURIComponent(ref)}`, {
+					query: { recursive: treeOptions.recursive ? "true" : void 0 },
+					signal: treeOptions.signal
+				});
+				const prefix = treeOptions.path?.replace(/^\/|\/$/g, "");
+				return {
+					items: (data.tree ?? []).filter((entry) => !prefix || entry.path.startsWith(`${prefix}/`)).map(toTreeEntry),
+					...data.truncated ? { warnings: [{
+						code: "tree_truncated",
+						message: "Origin truncated the tree; read subtrees non-recursively instead",
+						subject: ref
+					}] } : {}
+				};
+			}),
+			branchesPage: verb("unverified", async (repo, listOptions = {}) => {
+				const page = await tokenPage(`${repoPath(repo)}/branches`, "branches", listOptions);
+				return {
+					items: page.items.map(toBranch),
+					cursor: page.cursor
+				};
+			}),
+			tagsPage: verb("unverified", async (repo, listOptions = {}) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/git/matching-refs`, {
+					query: { ref: "tags/" },
+					signal: listOptions.signal
+				});
+				return { items: (data ?? []).map(toTag) };
+			}),
+			resolveRef: verb("unverified", async (repo, ref, options) => (await fetcher.json(`${repoPath(repo)}/commits/${encodeURIComponent(ref)}`, { signal: options?.signal })).data.sha),
+			commitsPage: verb("unverified", async (repo, query = {}) => {
+				const page = await tokenPage(`${repoPath(repo)}/commits`, "commits", {
+					...query,
+					query: {
+						sha: query.ref,
+						authorEmails: query.author,
+						since: query.since?.toISOString()
+					}
+				});
+				return {
+					items: page.items.map((raw) => toCommit(repo, raw)),
+					cursor: page.cursor
+				};
+			}),
+			commit: verb("unverified", async (repo, sha, options) => {
+				const [commit, files] = await Promise.all([fetcher.json(`${repoPath(repo)}/commits/${sha}`, { signal: options?.signal }), all(`${repoPath(repo)}/commits/${sha}/files`, "files", options)]);
+				return toCommit(repo, commit.data, files.map(toChangedFile));
+			}),
+			compare: verb("unverified", async (repo, base, head, options) => {
+				const basehead = encodeURIComponent(`${base}...${head}`);
+				const [comparison, files] = await Promise.all([fetcher.json(`${repoPath(repo)}/compare/${basehead}`, { signal: options?.signal }), all(`${repoPath(repo)}/compare/${basehead}/files`, "files", options)]);
+				return {
+					base,
+					head,
+					aheadBy: comparison.data.aheadBy,
+					behindBy: comparison.data.behindBy,
+					mergeBaseSha: comparison.data.mergeBaseCommit?.sha,
+					commits: [],
+					files: files.map(toChangedFile),
+					raw: comparison.data
+				};
+			})
+		},
+		traits: {
+			eventKinds: "native",
+			authKinds: [
+				"token",
+				"app",
+				"anonymous"
+			]
+		},
+		repos: {
+			get: verb("experimental", async (ref, options) => toRepo(instance, (await fetcher.json(repoPath(ref), { signal: options?.signal })).data)),
+			listPage: verb(repoAccess && "unverified", async (listOptions = {}) => {
+				if (auth?.type === "app") {
+					if (auth.installationId === void 0) throw new UnsupportedOperationError("An app without an installation has no repositories; use installations.repos()", context);
+					return reposPage(listOptions);
+				}
+				return userReposPage(listOptions);
+			})
+		},
+		installations: credentials && auth?.type === "app" && auth.installationId === void 0 ? verb("unverified", createInstallationsApi(credentials)) : void 0,
+		threads: {
+			get: perKind(PULL, get),
+			getMany: verb("experimental", (refs, options) => getManyConcurrently(refs, get, options)),
+			listPage: perKind(PULL, listPage),
+			eventsPage: verb("experimental", eventsPage),
+			filesPage: verb("unverified", async (thread, listOptions = {}) => {
+				const page = await tokenPage(`${pullPath(requireThread(thread, context))}/files`, "files", listOptions);
+				return {
+					items: page.items.map(toChangedFile),
+					cursor: page.cursor
+				};
+			}),
+			commitsPage: verb("unverified", async (thread, listOptions = {}) => {
+				const page = await tokenPage(`${pullPath(requireThread(thread, context))}/commits`, "commits", listOptions);
+				return {
+					items: page.items.map((raw) => toCommit(thread.repo, raw)),
+					cursor: page.cursor
+				};
+			}),
+			commentsPage: perKind(PULL, commentsPage),
+			comment: perKind(PULL, async (thread, body, options) => {
+				const ref = requireThread(thread, context);
+				return toComment(ref, (await fetcher.json(`${pullPath(ref)}/comments`, {
+					method: "POST",
+					json: { body },
+					signal: options?.signal
+				})).data);
+			}),
+			editComment: perKind(UNVERIFIED, async (ref, body, options) => toComment(ref.thread, (await fetcher.json(`${repoPath(ref.thread.repo)}/pulls/comments/${ref.id}`, {
+				method: "PATCH",
+				json: { body },
+				signal: options?.signal
+			})).data)),
+			deleteComment: perKind(UNVERIFIED, async (ref, options) => {
+				await fetcher.raw(`${repoPath(ref.thread.repo)}/pulls/comments/${ref.id}`, {
+					method: "DELETE",
+					signal: options?.signal
+				});
+			}),
+			create: perKind(UNVERIFIED, async (repo, input, options) => {
+				if (input.assignees?.length) throw new UnsupportedOperationError("Cursor Origin pull requests have no assignees", context);
+				if (!input.head || !input.base) throw new UnsupportedOperationError("Creating a pull request needs head and base branches", context);
+				const { data } = await fetcher.json(`${repoPath(repo)}/pulls`, {
+					method: "POST",
+					json: {
+						title: input.title,
+						body: input.body ?? "",
+						head: input.head,
+						base: input.base,
+						draft: input.draft ?? false
+					},
+					signal: options?.signal
+				});
+				const ref = {
+					forge: FORGE,
+					instance,
+					repo,
+					kind: "pull_request",
+					number: data.number
+				};
+				if (input.labels?.length) await fetcher.raw(`${pullPath(ref)}/labels`, {
+					method: "PUT",
+					json: { labels: input.labels },
+					signal: options?.signal
+				});
+				return toThread(ref, data);
+			}),
+			update: perKind(UNVERIFIED, async (thread, input, options) => {
+				const ref = requireThread(thread, context);
+				return toThread(ref, (await fetcher.json(pullPath(ref), {
+					method: "PATCH",
+					json: input,
+					signal: options?.signal
+				})).data);
+			}),
+			close: perKind(PULL, async (thread, options) => {
+				await fetcher.raw(pullPath(requireThread(thread, context)), {
+					method: "PATCH",
+					json: { state: "closed" },
+					signal: options?.signal
+				});
+			}),
+			reopen: perKind(PULL, async (thread, options) => {
+				await fetcher.raw(pullPath(requireThread(thread, context)), {
+					method: "PATCH",
+					json: { state: "open" },
+					signal: options?.signal
+				});
+			}),
+			setLabels: perKind(UNVERIFIED, async (thread, labels, options) => {
+				await fetcher.raw(`${pullPath(requireThread(thread, context))}/labels`, {
+					method: "PUT",
+					json: { labels },
+					signal: options?.signal
+				});
+			}),
+			requestReview: perKind(UNVERIFIED, async (thread, reviewers, options) => {
+				const users = reviewers.map((reviewer) => typeof reviewer === "string" ? reviewer : reviewer.id);
+				await fetcher.raw(`${pullPath(requireThread(thread, context))}/requested_reviewers`, {
+					method: "POST",
+					json: { users },
+					signal: options?.signal
+				});
+			}),
+			merge: verb("experimental", async (thread, mergeOptions = {}, hooks = {}) => {
+				const ref = requireThread(thread, context);
+				if (mergeOptions.whenChecksPass) throw new UnsupportedOperationError("Cursor Origin has no merge queue or auto-merge", context);
+				if (mergeOptions.title) throw new UnsupportedOperationError("Cursor Origin does not take a merge commit title", context);
+				if (mergeOptions.message) throw new UnsupportedOperationError("Cursor Origin does not take a merge commit message", context);
+				if (mergeOptions.method && mergeOptions.method !== "merge" && mergeOptions.method !== "squash") throw new UnsupportedOperationError(`Cursor Origin does not support the ${mergeOptions.method} merge method`, context);
+				let method = mergeOptions.method;
+				if (!method) {
+					const { data: repo } = await fetcher.json(repoPath(ref.repo), { signal: mergeOptions.signal });
+					method = soleMergeMethod({
+						merge: repo.allowMergeCommit,
+						squash: repo.allowSquashMerge
+					}, context);
+				}
+				await hooks.beforeMerge?.();
+				await fetcher.raw(`${pullPath(ref)}/merge`, {
+					method: "POST",
+					json: {
+						mergeMethod: method,
+						expectedHeadSha: mergeOptions.sha
+					},
+					mapError: toMergeError,
+					signal: mergeOptions.signal
+				});
+			}),
+			reviewsPage: verb("experimental", async (thread, listOptions = {}) => {
+				const ref = requireThread(thread, context);
+				const page = await tokenPage(`${pullPath(ref)}/reviews`, "reviews", listOptions);
+				return {
+					items: page.items.map((raw) => toReview(ref, raw)),
+					cursor: page.cursor
+				};
+			}),
+			createReview: verb("unverified", createReview),
+			reviewThreads: verb("unverified", {
+				resolveReviewThread: (_thread, id, options) => setThreadResolved(id, true, options),
+				unresolveReviewThread: (_thread, id, options) => setThreadResolved(id, false, options)
+			}),
+			checks: perKind(PULL, async (thread, options) => {
+				const ref = requireThread(thread, context);
+				const { data } = await fetcher.json(pullPath(ref), { signal: options?.signal });
+				const sha = data.version?.headSha ?? data.head?.sha;
+				return { items: sha ? await headChecks(ref.repo, sha, options?.signal) : [] };
+			})
+		},
+		webhooks: {},
+		scopes: () => ({ note: "An Origin app installation token; Origin has no per-verb scopes" })
+	};
+}
+const ORIGIN = {
+	forge: FORGE,
+	experimental: true,
+	anonymous: "webhooks",
+	baseUrl: "https://api.cursor.com",
+	apiPath: "/v1/origin",
+	instance: (host) => host === "api.cursor.com" ? "origin.cursor.com" : host,
+	headers: { accept: "application/json" },
+	prepare: ({ options, state, baseUrl, headers }) => options.auth?.type === "app" ? state ?? createOriginAppCredentials(options.auth, (authHeaders) => createFetcherFor(baseUrl, headers, options, authHeaders)) : void 0,
+	authHeaders: ({ options, state }) => {
+		const auth = options.auth;
+		if (!auth || auth.type === "anonymous") return;
+		if (auth.type === "token") return async () => ({ authorization: `Bearer ${await resolveToken(auth)}` });
+		const app = state;
+		return auth.installationId === void 0 ? async () => ({ authorization: `Bearer ${await app.appJwt()}` }) : async () => ({ authorization: `Bearer ${await app.installationToken(String(auth.installationId))}` });
+	},
+	setup: setupOrigin
+};
+/**
+* Creates a Cursor Origin provider. Experimental: built against the
+* `v1alpha1` API, which Cursor publishes as Early Beta.
+*/
+const cursorOrigin = /* @__PURE__ */ defineForgeProvider({
+	...ORIGIN,
+	webhooks: cursorOriginWebhooks
+});
+/** `cursorOrigin()` without webhook ingestion, for bundles that never receive a delivery. */
+const cursorOriginLite = /* @__PURE__ */ defineForgeProvider(ORIGIN);
+function createFetcherFor(baseUrl, headers, options, authHeaders) {
+	return createFetcher({
+		baseUrl,
+		headers,
+		fetch: options.fetch,
+		timeout: options.timeout,
+		authHeaders,
+		context: { forge: FORGE }
+	});
+}
+//#endregion
+export { cursorOrigin as n, cursorOriginLite as r, ORIGIN_API_VERSION as t };