| import { sanitizeOpenCodeOutput } from '../../lib/opencode-errors.js'; |
| import { spawnProcess } from '@automaker/platform'; |
| import type { CiFailureSummary, CiState } from './types.js'; |
|
|
| export interface GitHubPullRequest { |
| number: number; |
| state: string; |
| url: string; |
| repository: string; |
| baseBranch: string; |
| baseSha: string; |
| headBranch: string; |
| headSha: string; |
| merged: boolean; |
| mergeCommitSha: string | null; |
| } |
| export interface CiObservation { |
| headSha: string; |
| state: CiState; |
| observedAt: string; |
| runIds: string[]; |
| failures: CiFailureSummary[]; |
| } |
| export type GhRunner = (args: string[]) => Promise<string>; |
|
|
| const MAX_RUNS = 20; |
| const MAX_JOBS = 20; |
| const MAX_FAILURES = 10; |
| const MAX_EXCERPT = 2_000; |
|
|
| export class GitHubCiObserver { |
| constructor( |
| private readonly runner: GhRunner = GitHubCiObserver.defaultRunner, |
| private readonly secrets: string[] = [ |
| process.env.GITHUB_PAT, |
| process.env.JULES_API_KEY, |
| process.env.COMPATIBLE_API_KEY, |
| ].filter((value): value is string => Boolean(value)) |
| ) {} |
|
|
| static async defaultRunner(args: string[]) { |
| const env = Object.fromEntries( |
| [ |
| ['PATH', process.env.PATH], |
| ['HOME', process.env.HOME], |
| ['GH_TOKEN', process.env.GITHUB_PAT], |
| ].filter((entry): entry is [string, string] => Boolean(entry[1])) |
| ); |
| const result = await spawnProcess({ command: 'gh', args, env, cwd: process.cwd() }); |
| if (result.exitCode !== 0) |
| throw new Error( |
| `GITHUB_OBSERVATION_FAILED: ${sanitizeOpenCodeOutput(result.stderr || `gh exited ${result.exitCode}`)}` |
| ); |
| return result.stdout; |
| } |
|
|
| async api(args: string[]): Promise<Record<string, any>> { |
| const text = await this.runner(args); |
| return text.trim() ? JSON.parse(text) : {}; |
| } |
|
|
| async getPullRequest(repository: string, number: number): Promise<GitHubPullRequest> { |
| const value = JSON.parse( |
| await this.runner(['api', `repos/${repository}/pulls/${number}`]) |
| ) as Record<string, any>; |
| return { |
| number: value.number, |
| state: String(value.state).toUpperCase(), |
| url: value.html_url, |
| repository: `${value.base.repo.owner.login}/${value.base.repo.name}`.toLowerCase(), |
| baseBranch: value.base.ref, |
| baseSha: value.base.sha, |
| headBranch: value.head.ref, |
| headSha: value.head.sha, |
| merged: Boolean(value.merged), |
| mergeCommitSha: value.merge_commit_sha || null, |
| }; |
| } |
|
|
| async getPullRequestDiff(repository: string, number: number): Promise<string> { |
| return ( |
| await this.runner([ |
| 'api', |
| '-H', |
| 'Accept: application/vnd.github.v3.diff', |
| `repos/${repository}/pulls/${number}`, |
| ]) |
| ).slice(0, 50_000); |
| } |
|
|
| async observe(repository: string, headSha: string): Promise<CiObservation> { |
| const [checksValue, runsValue] = await Promise.all([ |
| this.json(['api', `repos/${repository}/commits/${headSha}/check-runs`]), |
| this.json([ |
| 'api', |
| `repos/${repository}/actions/runs?head_sha=${headSha}&per_page=${MAX_RUNS}`, |
| ]), |
| ]); |
| const checks = (checksValue.check_runs || []).filter( |
| (check: any) => !check.head_sha || check.head_sha === headSha |
| ); |
| const runs = (runsValue.workflow_runs || []) |
| .filter((run: any) => run.head_sha === headSha) |
| .slice(0, MAX_RUNS); |
| if (!checks.length && !runs.length) return this.result(headSha, 'not-configured', [], []); |
| const conclusions = [...checks, ...runs].map((item: any) => ({ |
| status: item.status, |
| conclusion: item.conclusion, |
| })); |
| let state: CiState = 'success'; |
| if (conclusions.some((item) => item.status !== 'completed' && item.status !== 'COMPLETED')) |
| state = 'pending'; |
| else if ( |
| conclusions.some((item) => |
| ['failure', 'timed_out', 'action_required'].includes(item.conclusion) |
| ) |
| ) |
| state = 'failure'; |
| else if (conclusions.some((item) => item.conclusion === 'cancelled')) state = 'cancelled'; |
| else if (conclusions.some((item) => item.conclusion !== 'success')) state = 'unknown'; |
| const failures = state === 'failure' ? await this.failureEvidence(repository, runs) : []; |
| return this.result( |
| headSha, |
| state, |
| runs.map((run: any) => String(run.id)), |
| failures |
| ); |
| } |
|
|
| private async failureEvidence(repository: string, runs: any[]): Promise<CiFailureSummary[]> { |
| const failures: CiFailureSummary[] = []; |
| for (const run of runs.filter((item) => item.conclusion === 'failure').slice(0, MAX_RUNS)) { |
| const jobs = |
| ( |
| await this.json([ |
| 'api', |
| `repos/${repository}/actions/runs/${run.id}/jobs?per_page=${MAX_JOBS}`, |
| ]) |
| ).jobs || []; |
| for (const job of jobs |
| .filter((item: any) => item.conclusion === 'failure') |
| .slice(0, MAX_JOBS)) { |
| const step = (job.steps || []).find((item: any) => item.conclusion === 'failure'); |
| let excerpt = ''; |
| try { |
| excerpt = await this.runner(['api', `repos/${repository}/actions/jobs/${job.id}/logs`]); |
| } catch { |
| excerpt = 'Log excerpt unavailable.'; |
| } |
| failures.push({ |
| workflowName: run.name || 'workflow', |
| workflowRunId: String(run.id), |
| jobName: job.name || 'job', |
| jobId: String(job.id), |
| failedStep: step?.name || 'unknown', |
| conclusion: job.conclusion, |
| excerpt: this.redact(excerpt).slice(-MAX_EXCERPT), |
| observedAt: new Date().toISOString(), |
| }); |
| if (failures.length >= MAX_FAILURES) return failures; |
| } |
| } |
| return failures; |
| } |
|
|
| private redact(value: string) { |
| return this.secrets.reduce((text, secret) => text.split(secret).join('[REDACTED]'), value); |
| } |
| private async json(args: string[]): Promise<Record<string, any>> { |
| return JSON.parse(await this.runner(args)); |
| } |
| private result(headSha: string, state: CiState, runIds: string[], failures: CiFailureSummary[]) { |
| return { headSha, state, runIds, failures, observedAt: new Date().toISOString() }; |
| } |
| } |
|
|
