mirror of
https://github.com/google-gemini/gemini-cli.git
synced 2026-04-12 14:22:00 -07:00
282 lines
9.1 KiB
JavaScript
Executable File
282 lines
9.1 KiB
JavaScript
Executable File
#!/usr/bin/env node
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2026 Google LLC
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
import { execSync } from 'node:child_process';
|
|
|
|
const BRANCH =
|
|
process.argv[2] || execSync('git branch --show-current').toString().trim();
|
|
const RUN_ID_OVERRIDE = process.argv[3];
|
|
|
|
let REPO;
|
|
try {
|
|
const remoteUrl = execSync('git remote get-url origin').toString().trim();
|
|
REPO = remoteUrl
|
|
.replace(/.*github\.com[\/:]/, '')
|
|
.replace(/\.git$/, '')
|
|
.trim();
|
|
} catch (e) {
|
|
REPO = 'google-gemini/gemini-cli';
|
|
}
|
|
|
|
const FAILED_FILES = new Set();
|
|
|
|
function runGh(args) {
|
|
try {
|
|
return execSync(`gh ${args}`, {
|
|
stdio: ['ignore', 'pipe', 'ignore'],
|
|
}).toString();
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function fetchFailuresViaApi(jobId) {
|
|
try {
|
|
const cmd = `gh api repos/${REPO}/actions/jobs/${jobId}/logs | grep -iE " FAIL |❌|ERROR|Lint failed|Build failed|Exception|failed with exit code"`;
|
|
return execSync(cmd, {
|
|
stdio: ['ignore', 'pipe', 'ignore'],
|
|
maxBuffer: 10 * 1024 * 1024,
|
|
}).toString();
|
|
} catch (e) {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
function isNoise(line) {
|
|
const lower = line.toLowerCase();
|
|
return (
|
|
lower.includes('* [new branch]') ||
|
|
lower.includes('npm warn') ||
|
|
lower.includes('fetching updates') ||
|
|
lower.includes('node:internal/errors') ||
|
|
lower.includes('at ') || // Stack traces
|
|
lower.includes('checkexecsyncerror') ||
|
|
lower.includes('node_modules')
|
|
);
|
|
}
|
|
|
|
function extractTestFile(failureText) {
|
|
const cleanLine = failureText
|
|
.replace(/[|#\[\]()]/g, ' ')
|
|
.replace(/<[^>]*>/g, ' ')
|
|
.trim();
|
|
const fileMatch = cleanLine.match(/([\w\/._-]+\.test\.[jt]sx?)/);
|
|
if (fileMatch) return fileMatch[1];
|
|
return null;
|
|
}
|
|
|
|
function generateTestCommand(failedFilesMap) {
|
|
const workspaceToFiles = new Map();
|
|
for (const [file, info] of failedFilesMap.entries()) {
|
|
if (
|
|
['Job Error', 'Unknown File', 'Build Error', 'Lint Error'].includes(file)
|
|
)
|
|
continue;
|
|
let workspace = '@google/gemini-cli';
|
|
let relPath = file;
|
|
if (file.startsWith('packages/core/')) {
|
|
workspace = '@google/gemini-cli-core';
|
|
relPath = file.replace('packages/core/', '');
|
|
} else if (file.startsWith('packages/cli/')) {
|
|
workspace = '@google/gemini-cli';
|
|
relPath = file.replace('packages/cli/', '');
|
|
}
|
|
relPath = relPath.replace(/^.*packages\/[^\/]+\//, '');
|
|
if (!workspaceToFiles.has(workspace))
|
|
workspaceToFiles.set(workspace, new Set());
|
|
workspaceToFiles.get(workspace).add(relPath);
|
|
}
|
|
const commands = [];
|
|
for (const [workspace, files] of workspaceToFiles.entries()) {
|
|
commands.push(`npm test -w ${workspace} -- ${Array.from(files).join(' ')}`);
|
|
}
|
|
return commands.join(' && ');
|
|
}
|
|
|
|
async function monitor() {
|
|
let targetRunIds = [];
|
|
if (RUN_ID_OVERRIDE) {
|
|
targetRunIds = [RUN_ID_OVERRIDE];
|
|
} else {
|
|
// 1. Get runs directly associated with the branch
|
|
const runListOutput = runGh(
|
|
`run list --branch "${BRANCH}" --limit 10 --json databaseId,status,workflowName,createdAt`,
|
|
);
|
|
if (runListOutput) {
|
|
const runs = JSON.parse(runListOutput);
|
|
const activeRuns = runs.filter((r) => r.status !== 'completed');
|
|
if (activeRuns.length > 0) {
|
|
targetRunIds = activeRuns.map((r) => r.databaseId);
|
|
} else if (runs.length > 0) {
|
|
const latestTime = new Date(runs[0].createdAt).getTime();
|
|
targetRunIds = runs
|
|
.filter((r) => latestTime - new Date(r.createdAt).getTime() < 60000)
|
|
.map((r) => r.databaseId);
|
|
}
|
|
}
|
|
|
|
// 2. Get runs associated with commit statuses (handles chained/indirect runs)
|
|
try {
|
|
const headSha = execSync(`git rev-parse "${BRANCH}"`).toString().trim();
|
|
const statusOutput = runGh(
|
|
`api repos/${REPO}/commits/${headSha}/status -q '.statuses[] | select(.target_url | contains("actions/runs/")) | .target_url'`,
|
|
);
|
|
if (statusOutput) {
|
|
const statusRunIds = statusOutput
|
|
.split('\n')
|
|
.filter(Boolean)
|
|
.map((url) => {
|
|
const match = url.match(/actions\/runs\/(\d+)/);
|
|
return match ? parseInt(match[1], 10) : null;
|
|
})
|
|
.filter(Boolean);
|
|
|
|
for (const runId of statusRunIds) {
|
|
if (!targetRunIds.includes(runId)) {
|
|
targetRunIds.push(runId);
|
|
}
|
|
}
|
|
}
|
|
} catch (e) {
|
|
// Ignore if branch/SHA not found or API fails
|
|
}
|
|
|
|
if (targetRunIds.length > 0) {
|
|
const runNames = [];
|
|
for (const runId of targetRunIds) {
|
|
const runInfo = runGh(`run view "${runId}" --json workflowName`);
|
|
if (runInfo) {
|
|
runNames.push(JSON.parse(runInfo).workflowName);
|
|
}
|
|
}
|
|
console.log(`Monitoring workflows: ${[...new Set(runNames)].join(', ')}`);
|
|
}
|
|
}
|
|
|
|
if (targetRunIds.length === 0) {
|
|
console.log(`No runs found for branch ${BRANCH}.`);
|
|
process.exit(0);
|
|
}
|
|
|
|
while (true) {
|
|
let allPassed = 0,
|
|
allFailed = 0,
|
|
allRunning = 0,
|
|
allQueued = 0,
|
|
totalJobs = 0;
|
|
let anyRunInProgress = false;
|
|
const fileToTests = new Map();
|
|
let failuresFoundInLoop = false;
|
|
|
|
for (const runId of targetRunIds) {
|
|
const runOutput = runGh(
|
|
`run view "${runId}" --json databaseId,status,conclusion,workflowName`,
|
|
);
|
|
if (!runOutput) continue;
|
|
const run = JSON.parse(runOutput);
|
|
if (run.status !== 'completed') anyRunInProgress = true;
|
|
|
|
const jobsOutput = runGh(`run view "${runId}" --json jobs`);
|
|
if (jobsOutput) {
|
|
const { jobs } = JSON.parse(jobsOutput);
|
|
totalJobs += jobs.length;
|
|
const failedJobs = jobs.filter((j) => j.conclusion === 'failure');
|
|
if (failedJobs.length > 0) {
|
|
failuresFoundInLoop = true;
|
|
for (const job of failedJobs) {
|
|
const failures = fetchFailuresViaApi(job.databaseId);
|
|
if (failures.trim()) {
|
|
failures.split('\n').forEach((line) => {
|
|
if (!line.trim() || isNoise(line)) return;
|
|
const file = extractTestFile(line);
|
|
const filePath =
|
|
file ||
|
|
(line.toLowerCase().includes('lint')
|
|
? 'Lint Error'
|
|
: line.toLowerCase().includes('build')
|
|
? 'Build Error'
|
|
: 'Unknown File');
|
|
let testName = line;
|
|
if (line.includes(' > ')) {
|
|
testName = line.split(' > ').slice(1).join(' > ').trim();
|
|
}
|
|
if (!fileToTests.has(filePath))
|
|
fileToTests.set(filePath, new Set());
|
|
fileToTests.get(filePath).add(testName);
|
|
});
|
|
} else {
|
|
const step =
|
|
job.steps?.find((s) => s.conclusion === 'failure')?.name ||
|
|
'unknown';
|
|
const category = step.toLowerCase().includes('lint')
|
|
? 'Lint Error'
|
|
: step.toLowerCase().includes('build')
|
|
? 'Build Error'
|
|
: 'Job Error';
|
|
if (!fileToTests.has(category))
|
|
fileToTests.set(category, new Set());
|
|
fileToTests
|
|
.get(category)
|
|
.add(`${job.name}: Failed at step "${step}"`);
|
|
}
|
|
}
|
|
}
|
|
for (const job of jobs) {
|
|
if (job.status === 'in_progress') allRunning++;
|
|
else if (job.status === 'queued') allQueued++;
|
|
else if (job.conclusion === 'success') allPassed++;
|
|
else if (job.conclusion === 'failure') allFailed++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (failuresFoundInLoop) {
|
|
console.log(
|
|
`\n\n❌ Failures detected across ${allFailed} job(s). Stopping monitor...`,
|
|
);
|
|
console.log('\n--- Structured Failure Report (Noise Filtered) ---');
|
|
for (const [file, tests] of fileToTests.entries()) {
|
|
console.log(`\nCategory/File: ${file}`);
|
|
// Limit output per file if it's too large
|
|
const testsArr = Array.from(tests).map((t) =>
|
|
t.length > 500 ? t.substring(0, 500) + '... [TRUNCATED]' : t,
|
|
);
|
|
testsArr.slice(0, 10).forEach((t) => console.log(` - ${t}`));
|
|
if (testsArr.length > 10)
|
|
console.log(` ... and ${testsArr.length - 10} more`);
|
|
}
|
|
const testCmd = generateTestCommand(fileToTests);
|
|
if (testCmd) {
|
|
console.log('\n🚀 Run this to verify fixes:');
|
|
console.log(testCmd);
|
|
} else if (
|
|
Array.from(fileToTests.keys()).some((k) => k.includes('Lint'))
|
|
) {
|
|
console.log('\n🚀 Run this to verify lint fixes:\nnpm run lint:all');
|
|
}
|
|
console.log('---------------------------------');
|
|
process.exit(1);
|
|
}
|
|
|
|
const completed = allPassed + allFailed;
|
|
process.stdout.write(
|
|
`\r⏳ Monitoring ${targetRunIds.length} runs... ${completed}/${totalJobs} jobs (${allPassed} passed, ${allFailed} failed, ${allRunning} running, ${allQueued} queued) `,
|
|
);
|
|
if (!anyRunInProgress) {
|
|
console.log('\n✅ All workflows passed!');
|
|
process.exit(0);
|
|
}
|
|
await new Promise((r) => setTimeout(r, 15000));
|
|
}
|
|
}
|
|
|
|
monitor().catch((err) => {
|
|
console.error('\nMonitor error:', err.message);
|
|
process.exit(1);
|
|
});
|