Skip to content
← Public packages

@kentcdodds/devin

Start, monitor, and manage Devin sessions, knowledge, playbooks, and schedules via the Devin v3 API

FollowFork

Files

attention-runtime.ts

127 lines · 3.9 KB · TypeScript
import githubRequest from 'kody:@kentcdodds/github/request'
import { DevinApiError, clampInt } from './client.ts'
import {
	type AttentionMessage,
	type AttentionPr,
	normalizePrState,
	parsePrUrl,
} from './attention.ts'
import { listMessages, type SessionMessage } from '../sessions.ts'

/** GitHub account alias passed to `@kentcdodds/github/request` by default. */
export const DEFAULT_GITHUB_ACCOUNT = 'kent'

export function sleep(ms: number) {
	return new Promise((resolve) => setTimeout(resolve, ms))
}

/** Retry Devin 429/5xx a couple of times with short backoff. */
export async function withRetry<T>(fn: () => Promise<T>, retries = 2): Promise<T> {
	let attempt = 0
	while (true) {
		try {
			return await fn()
		} catch (error) {
			const status = error instanceof DevinApiError ? error.status : 0
			const retryable = status === 429 || status >= 500
			if (!retryable || attempt >= retries) throw error
			attempt += 1
			await sleep(400 * 2 ** attempt)
		}
	}
}

/** All messages for a session (chronological), following cursors up to `maxPages`. */
export async function fetchAllMessages(
	devinId: string,
	orgId?: string,
	maxPages = 5,
): Promise<AttentionMessage[]> {
	const items: SessionMessage[] = []
	let after: string | undefined
	for (let page = 0; page < maxPages; page++) {
		const result = await withRetry(() =>
			listMessages({ devinId, orgId, first: 200, after }),
		)
		items.push(...(result.items ?? []))
		if (!result.has_next_page || !result.end_cursor) break
		after = result.end_cursor
	}
	return items
}

/** Run `fn` over `items` with at most `limit` in flight. */
export async function mapConcurrent<T, R>(
	items: T[],
	limit: number,
	fn: (item: T, index: number) => Promise<R>,
	shouldStart: () => boolean = () => true,
): Promise<{ results: Array<R | undefined>; started: number }> {
	const results: Array<R | undefined> = new Array(items.length)
	let next = 0
	async function worker() {
		while (next < items.length && shouldStart()) {
			const index = next++
			results[index] = await fn(items[index]!, index)
		}
	}
	const size = clampInt(limit, 1, 64, 8)
	await Promise.all(Array.from({ length: Math.min(size, items.length) }, worker))
	return { results, started: next }
}

type GithubPr = {
	state?: string
	merged?: boolean
	merged_at?: string | null
	merge_commit_sha?: string | null
}

/** Read one PR's state and merge commit from GitHub. */
export async function fetchGithubPr(
	pr: AttentionPr,
	account: string,
): Promise<AttentionPr> {
	const parsed = parsePrUrl(pr.url)
	if (!parsed) return pr
	const response = (await githubRequest({
		account: account as never,
		path: `/repos/${parsed.owner}/${parsed.repo}/pulls/${parsed.number}`,
		timeoutMs: 8000,
	})) as { ok?: boolean; status?: number; data?: GithubPr }
	if (!response?.ok || !response.data) {
		throw new Error(`GitHub PR read failed (${String(response?.status ?? 'error')})`)
	}
	const data = response.data
	const merged = Boolean(data.merged || data.merged_at)
	return {
		url: pr.url,
		state: merged ? 'merged' : normalizePrState(data.state),
		mergeCommit: merged ? (data.merge_commit_sha ?? null) : null,
	}
}

/**
 * Whether `liveCommit` contains `mergeCommit` (GitHub compare base...head is
 * `ahead` or `identical`). Null when GitHub cannot say.
 */
export async function commitIncludedIn(
	prUrl: string,
	mergeCommit: string,
	liveCommit: string,
	account: string,
): Promise<boolean | null> {
	const parsed = parsePrUrl(prUrl)
	if (!parsed) return null
	const response = (await githubRequest({
		account: account as never,
		path: `/repos/${parsed.owner}/${parsed.repo}/compare/${encodeURIComponent(mergeCommit)}...${encodeURIComponent(liveCommit)}`,
		query: { per_page: '1' },
		timeoutMs: 8000,
	})) as { ok?: boolean; data?: { status?: string } }
	if (!response?.ok) return null
	const status = response.data?.status
	if (status === 'ahead' || status === 'identical') return true
	if (status === 'behind' || status === 'diverged') return false
	return null
}