mirror of
https://github.com/garrytan/gstack.git
synced 2026-11-19 14:44:44 +01:00
A security finding that an owner ruled a note, dispositioned, or that review deferred now shows in a PR body only as an opaque id and "security finding, details recorded privately". Why: on a public repository the old lines named the file, line and reason of a live exposure outside the PR's change. Nothing to do: other findings print exactly as before, and the details stay in the private approval record. Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> Review-Finding: p1/specialist-batched#1 reader=security Review-Finding: p1/red-team#1 reader=red-team
55 lines
3.4 KiB
TypeScript
55 lines
3.4 KiB
TypeScript
/**
|
|
* Owner-ruled notes (GST-1537, docs/ship-policy.md#ruled-notes): the owner's ruling that a review finding ships as a
|
|
* disclosed note instead of a fix. A ruling is one approved gstack-approvals row (`gstack-approvals rule`), with scope
|
|
* `ruled_note <finding fingerprint> <head>` and ask `ruled_note <finding fingerprint> at <head>: <reason>`, where head is the
|
|
* full sha of the stop head the owner ruled at; the row's `by` is the ruler and its `recorded_at` the time. A review-log field
|
|
* never makes one, so the lane that logged a finding cannot close it.
|
|
*/
|
|
import { spawnSync } from 'node:child_process';
|
|
import * as fs from 'node:fs';
|
|
import * as path from 'node:path';
|
|
import { locate, readRecord, type ApprovalRow, type Env } from './approval-record';
|
|
import { isSecurityFinding, REDACTED_FINDING, REDACTED_REASON } from './security-findings';
|
|
|
|
export interface RuledNote { finding: string; head: string; by: string; reason: string; at: string; approval: string }
|
|
|
|
const SCOPE = /^ruled_note (\S+) ([0-9a-f]{40})$/;
|
|
const ASK = /^ruled_note (\S+) at ([0-9a-f]{40}): (\S(?:.*\S)?)$/;
|
|
/** A ruler gstack names for itself (the no-stop default's `gstack no-stop default (K1)`) is no owner. */
|
|
export const GSTACK_ACTOR = /^gstack\b/i;
|
|
export const RULED_NOTE_SCOPE = /^\s*ruled_note\b/;
|
|
|
|
export const ruledNoteRow = (finding: string, head: string, reason: string) => ({ scope: `ruled_note ${finding} ${head}`, ask: `ruled_note ${finding} at ${head}: ${reason}` });
|
|
|
|
/** The approved ruling rows, one per finding and head (the newest wins). */
|
|
export function ruledNotes(rows: readonly ApprovalRow[]): RuledNote[] {
|
|
const byFinding = new Map<string, RuledNote>();
|
|
for (const r of rows) {
|
|
const scope = SCOPE.exec(r.scope), ask = ASK.exec(r.ask);
|
|
if (r.outcome !== 'approved' || !scope || !ask || ask[1] !== scope[1] || ask[2] !== scope[2] || GSTACK_ACTOR.test(r.by)) continue;
|
|
const finding = scope[1]!, head = scope[2]!, key = `${finding} ${head}`;
|
|
byFinding.delete(key);
|
|
byFinding.set(key, { finding, head, by: r.by, reason: ask[3]!, at: r.recorded_at, approval: r.id });
|
|
}
|
|
return [...byFinding.values()];
|
|
}
|
|
|
|
/** The rulings in the checked-out branch's approval record (and its mirror). */
|
|
export function readRuledNotes(cwd: string, env: Env = process.env): RuledNote[] {
|
|
const loc = locate({ cwd, env });
|
|
return 'code' in loc ? [] : ruledNotes(readRecord(loc).rows);
|
|
}
|
|
|
|
/** The ruling as public text may carry it: a security-class finding's fingerprint and reason stay in the approval record (GST-3076). */
|
|
export const publicRuledNote = (n: RuledNote): RuledNote => isSecurityFinding(n.finding) ? { ...n, finding: REDACTED_FINDING, reason: REDACTED_REASON } : n;
|
|
|
|
/** The one-line form finish prints after `RULED_NOTE: ` and the PR body carries after `Ruled note: `, from publicRuledNote. */
|
|
export const ruledNoteText = (note: RuledNote) => { const n = publicRuledNote(note); return `${n.finding} at ${n.head.slice(0, 12)} ruled by ${n.by} at ${n.at}: ${n.reason} (approval ${n.approval})`; };
|
|
|
|
/** The /ship run open on this checkout (its marker in the git dir, which finish removes), if any. */
|
|
export function openShipRun(cwd: string): string | undefined {
|
|
const p = spawnSync('git', ['rev-parse', '--git-path', 'gstack-ship-run'], { cwd, encoding: 'utf8', timeout: 10_000 });
|
|
if (p.status !== 0 || !p.stdout.trim()) return undefined;
|
|
try { return fs.readFileSync(path.resolve(cwd, p.stdout.trim()), 'utf8').trim() || undefined; } catch { return undefined; }
|
|
}
|