pumuki 6.3.7

package/scripts/consumer-startup-unblock-args-defaults-lib.ts

@@ -0,0 +1,17 @@
+import {
+  DEFAULT_CONSUMER_STARTUP_UNBLOCK_AUTH_REPORT_FILE,
+  DEFAULT_CONSUMER_STARTUP_UNBLOCK_OUT_FILE,
+  DEFAULT_CONSUMER_STARTUP_UNBLOCK_REPO,
+  DEFAULT_CONSUMER_STARTUP_UNBLOCK_SUPPORT_BUNDLE_FILE,
+  DEFAULT_CONSUMER_STARTUP_UNBLOCK_WORKFLOW_LINT_FILE,
+  type ConsumerStartupUnblockCliOptions,
+} from './consumer-startup-unblock-args-contract';
+
+export const createConsumerStartupUnblockDefaultOptions =
+  (): ConsumerStartupUnblockCliOptions => ({
+    repo: DEFAULT_CONSUMER_STARTUP_UNBLOCK_REPO,
+    supportBundleFile: DEFAULT_CONSUMER_STARTUP_UNBLOCK_SUPPORT_BUNDLE_FILE,
+    authReportFile: DEFAULT_CONSUMER_STARTUP_UNBLOCK_AUTH_REPORT_FILE,
+    workflowLintReportFile: DEFAULT_CONSUMER_STARTUP_UNBLOCK_WORKFLOW_LINT_FILE,
+    outFile: DEFAULT_CONSUMER_STARTUP_UNBLOCK_OUT_FILE,
+  });

package/scripts/consumer-startup-unblock-args-lib.ts

@@ -0,0 +1,49 @@
+import {
+  CONSUMER_STARTUP_UNBLOCK_VALUE_ARG_SETTERS,
+  type ConsumerStartupUnblockValueArg,
+} from './consumer-startup-unblock-arg-setters-lib';
+import type { ConsumerStartupUnblockCliOptions } from './consumer-startup-unblock-args-contract';
+import { createConsumerStartupUnblockDefaultOptions } from './consumer-startup-unblock-args-defaults-lib';
+
+export type { ConsumerStartupUnblockCliOptions } from './consumer-startup-unblock-args-contract';
+export {
+  DEFAULT_CONSUMER_STARTUP_UNBLOCK_AUTH_REPORT_FILE,
+  DEFAULT_CONSUMER_STARTUP_UNBLOCK_OUT_FILE,
+  DEFAULT_CONSUMER_STARTUP_UNBLOCK_REPO,
+  DEFAULT_CONSUMER_STARTUP_UNBLOCK_SUPPORT_BUNDLE_FILE,
+  DEFAULT_CONSUMER_STARTUP_UNBLOCK_WORKFLOW_LINT_FILE,
+} from './consumer-startup-unblock-args-contract';
+
+const readRequiredArgValue = (
+  args: ReadonlyArray<string>,
+  index: number,
+  option: string
+): string => {
+  const value = args[index + 1];
+  if (!value) {
+    throw new Error(`Missing value for ${option}`);
+  }
+  return value;
+};
+
+export const parseConsumerStartupUnblockArgs = (
+  args: ReadonlyArray<string>
+): ConsumerStartupUnblockCliOptions => {
+  const options: ConsumerStartupUnblockCliOptions = createConsumerStartupUnblockDefaultOptions();
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg in CONSUMER_STARTUP_UNBLOCK_VALUE_ARG_SETTERS) {
+      const value = readRequiredArgValue(args, index, arg);
+      const setter =
+        CONSUMER_STARTUP_UNBLOCK_VALUE_ARG_SETTERS[arg as ConsumerStartupUnblockValueArg];
+      setter(options, value);
+      index += 1;
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+};

package/scripts/consumer-startup-unblock-auth-lib.ts

@@ -0,0 +1,16 @@
+import type { ParsedAuthReport } from './consumer-support-ticket-parser-lib';
+
+export const hasConsumerStartupUnblockUserScopeGap = (auth?: ParsedAuthReport): boolean => {
+  const missingScopes = (auth?.missingScopes ?? '')
+    .toLowerCase()
+    .split(',')
+    .map((scope) => scope.trim())
+    .filter((scope) => scope.length > 0);
+
+  if (missingScopes.includes('user')) {
+    return true;
+  }
+
+  const billingError = (auth?.billingError ?? '').toLowerCase();
+  return billingError.includes('user scope') || billingError.includes('"user" scope');
+};

package/scripts/consumer-startup-unblock-blockers-lib.ts

@@ -0,0 +1,65 @@
+import type { ParsedAuthReport, ParsedSupportBundle } from './consumer-support-ticket-parser-lib';
+import type { ParsedWorkflowLintReport } from './consumer-startup-unblock-contract';
+import { parseConsumerStartupUnblockInteger } from './consumer-startup-unblock-contract';
+import { hasConsumerStartupUnblockUserScopeGap } from './consumer-startup-unblock-auth-lib';
+
+export const collectConsumerStartupUnblockBlockers = (params: {
+  support?: ParsedSupportBundle;
+  auth?: ParsedAuthReport;
+  workflowLint?: ParsedWorkflowLintReport;
+}): {
+  blockers: string[];
+  startupFailureRuns?: number;
+  startupStalledRuns?: number;
+  authVerdict?: string;
+  missingUserScope: boolean;
+  lintFindingsCount: number;
+} => {
+  const blockers: string[] = [];
+  const jobsCount = parseConsumerStartupUnblockInteger(params.support?.jobsCount);
+  const artifactsCount = parseConsumerStartupUnblockInteger(params.support?.artifactsCount);
+
+  const startupFailureRuns = parseConsumerStartupUnblockInteger(
+    params.support?.startupFailureRuns
+  );
+  const startupStalledRuns = parseConsumerStartupUnblockInteger(
+    params.support?.startupStalledRuns
+  );
+  if (startupFailureRuns === undefined) {
+    blockers.push('Unable to determine startup_failure_runs from support bundle');
+  } else if (startupFailureRuns > 0) {
+    blockers.push(`Startup failures still present (${startupFailureRuns})`);
+  }
+  if (startupStalledRuns !== undefined && startupStalledRuns > 0) {
+    blockers.push(`Startup runs remain queued/stalled (${startupStalledRuns})`);
+  }
+
+  if (
+    params.support?.runUrls?.length &&
+    jobsCount === 0 &&
+    artifactsCount === 0
+  ) {
+    blockers.push('Workflow runs are stuck before job graph creation (jobs=0, artifacts=0)');
+  }
+
+  const authVerdict = params.auth?.verdict?.trim();
+  if (authVerdict && authVerdict.toUpperCase() !== 'READY') {
+    blockers.push(`Auth report verdict is ${authVerdict}`);
+  }
+
+  const missingUserScope = hasConsumerStartupUnblockUserScopeGap(params.auth);
+
+  const lintFindingsCount = params.workflowLint?.findingsCount ?? 0;
+  if (lintFindingsCount > 0) {
+    blockers.push(`Workflow lint report still has findings (${lintFindingsCount})`);
+  }
+
+  return {
+    blockers,
+    startupFailureRuns,
+    startupStalledRuns,
+    authVerdict,
+    missingUserScope,
+    lintFindingsCount,
+  };
+};

package/scripts/consumer-startup-unblock-cli-lib.ts

@@ -0,0 +1,10 @@
+export {
+  DEFAULT_CONSUMER_STARTUP_UNBLOCK_AUTH_REPORT_FILE,
+  DEFAULT_CONSUMER_STARTUP_UNBLOCK_OUT_FILE,
+  DEFAULT_CONSUMER_STARTUP_UNBLOCK_REPO,
+  DEFAULT_CONSUMER_STARTUP_UNBLOCK_SUPPORT_BUNDLE_FILE,
+  DEFAULT_CONSUMER_STARTUP_UNBLOCK_WORKFLOW_LINT_FILE,
+  parseConsumerStartupUnblockArgs,
+  type ConsumerStartupUnblockCliOptions,
+} from './consumer-startup-unblock-args-lib';
+export { readConsumerStartupUnblockInput } from './consumer-startup-unblock-input-lib';

package/scripts/consumer-startup-unblock-contract.ts

@@ -0,0 +1,42 @@
+export type ParsedWorkflowLintReport = {
+  exitCode?: number;
+  findingsCount: number;
+  findings: ReadonlyArray<string>;
+};
+
+export type ConsumerStartupUnblockSummary = {
+  verdict: 'READY_FOR_RETEST' | 'BLOCKED' | 'MISSING_INPUTS';
+  blockers: ReadonlyArray<string>;
+  startupFailureRuns?: number;
+  startupStalledRuns?: number;
+  authVerdict?: string;
+  missingUserScope: boolean;
+  lintFindingsCount: number;
+};
+
+export const dedupeConsumerStartupUnblockValues = (
+  values: ReadonlyArray<string>
+): string[] => {
+  const seen = new Set<string>();
+  const output: string[] = [];
+
+  for (const value of values) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    output.push(value);
+  }
+
+  return output;
+};
+
+export const parseConsumerStartupUnblockInteger = (
+  value?: string
+): number | undefined => {
+  if (!value) {
+    return undefined;
+  }
+  const parsed = Number.parseInt(value.trim(), 10);
+  return Number.isFinite(parsed) ? parsed : undefined;
+};

package/scripts/consumer-startup-unblock-input-lib.ts

@@ -0,0 +1,17 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+export const readConsumerStartupUnblockInput = (
+  cwd: string,
+  pathLike: string
+): { exists: boolean; content?: string } => {
+  const absolute = resolve(cwd, pathLike);
+  if (!existsSync(absolute)) {
+    return { exists: false };
+  }
+
+  return {
+    exists: true,
+    content: readFileSync(absolute, 'utf8'),
+  };
+};

package/scripts/consumer-startup-unblock-markdown-lib.ts

@@ -0,0 +1,47 @@
+import type { ParsedAuthReport, ParsedSupportBundle } from './consumer-support-ticket-parser-lib';
+import type {
+  ConsumerStartupUnblockSummary,
+  ParsedWorkflowLintReport,
+} from './consumer-startup-unblock-contract';
+import { buildConsumerStartupUnblockNextActionLines } from './consumer-startup-unblock-markdown-next-actions-lib';
+import {
+  buildConsumerStartupUnblockBlockerLines,
+  buildConsumerStartupUnblockHeaderLines,
+  buildConsumerStartupUnblockInputLines,
+  buildConsumerStartupUnblockSignalLines,
+} from './consumer-startup-unblock-markdown-sections-lib';
+
+export const buildConsumerStartupUnblockStatus = (params: {
+  repo: string;
+  supportBundlePath: string;
+  authReportPath: string;
+  workflowLintReportPath: string;
+  hasSupportBundle: boolean;
+  hasAuthReport: boolean;
+  hasWorkflowLintReport: boolean;
+  summary: ConsumerStartupUnblockSummary;
+  support?: ParsedSupportBundle;
+  auth?: ParsedAuthReport;
+  workflowLint?: ParsedWorkflowLintReport;
+}): string => {
+  const lines = [
+    ...buildConsumerStartupUnblockHeaderLines({
+      generatedAt: new Date().toISOString(),
+      repo: params.repo,
+      verdict: params.summary.verdict,
+    }),
+    ...buildConsumerStartupUnblockInputLines({
+      supportBundlePath: params.supportBundlePath,
+      authReportPath: params.authReportPath,
+      workflowLintReportPath: params.workflowLintReportPath,
+      hasSupportBundle: params.hasSupportBundle,
+      hasAuthReport: params.hasAuthReport,
+      hasWorkflowLintReport: params.hasWorkflowLintReport,
+    }),
+    ...buildConsumerStartupUnblockSignalLines(params.summary),
+    ...buildConsumerStartupUnblockBlockerLines(params.summary),
+    ...buildConsumerStartupUnblockNextActionLines(params.summary),
+  ];
+
+  return `${lines.join('\n')}\n`;
+};

package/scripts/consumer-startup-unblock-markdown-next-actions-lib.ts

@@ -0,0 +1,37 @@
+import type { ConsumerStartupUnblockSummary } from './consumer-startup-unblock-contract';
+
+export const buildConsumerStartupUnblockNextActionLines = (
+  summary: ConsumerStartupUnblockSummary
+): ReadonlyArray<string> => {
+  if (summary.verdict === 'READY_FOR_RETEST') {
+    return [
+      '## Next Actions',
+      '',
+      '- Re-trigger workflow_dispatch in the consumer repository.',
+      '- Capture run URL, jobs count, and artifact URLs.',
+      '',
+    ];
+  }
+
+  const lines: string[] = ['## Next Actions', ''];
+
+  if (summary.missingUserScope) {
+    lines.push(
+      '- Optional: add `user` scope only if account-level billing diagnostics are needed.'
+    );
+  }
+  if ((summary.startupFailureRuns ?? 1) > 0) {
+    lines.push(
+      '- Review repository/account Actions policy and billing constraints before rerun.'
+    );
+  }
+  if (summary.lintFindingsCount > 0) {
+    lines.push('- Fix workflow lint findings and rerun diagnostics.');
+  }
+  if (summary.verdict === 'MISSING_INPUTS') {
+    lines.push('- Generate required inputs using validation helper commands.');
+  }
+  lines.push('');
+
+  return lines;
+};

package/scripts/consumer-startup-unblock-markdown-sections-lib.ts

@@ -0,0 +1,53 @@
+import type { ConsumerStartupUnblockSummary } from './consumer-startup-unblock-contract';
+
+export const buildConsumerStartupUnblockHeaderLines = (params: {
+  generatedAt: string;
+  repo: string;
+  verdict: ConsumerStartupUnblockSummary['verdict'];
+}): ReadonlyArray<string> => [
+  '# Consumer Startup Failure Unblock Status',
+  '',
+  `- generated_at: ${params.generatedAt}`,
+  `- repository: \`${params.repo}\``,
+  `- verdict: ${params.verdict}`,
+  '',
+];
+
+export const buildConsumerStartupUnblockInputLines = (params: {
+  supportBundlePath: string;
+  authReportPath: string;
+  workflowLintReportPath: string;
+  hasSupportBundle: boolean;
+  hasAuthReport: boolean;
+  hasWorkflowLintReport: boolean;
+}): ReadonlyArray<string> => [
+  '## Inputs',
+  '',
+  `- support_bundle: \`${params.supportBundlePath}\` (${params.hasSupportBundle ? 'found' : 'missing'})`,
+  `- auth_report: \`${params.authReportPath}\` (${params.hasAuthReport ? 'found' : 'missing'})`,
+  `- workflow_lint_report: \`${params.workflowLintReportPath}\` (${params.hasWorkflowLintReport ? 'found' : 'missing, optional'})`,
+  '',
+];
+
+export const buildConsumerStartupUnblockSignalLines = (
+  summary: ConsumerStartupUnblockSummary
+): ReadonlyArray<string> => [
+  '## Signals',
+  '',
+  `- startup_failure_runs: ${summary.startupFailureRuns ?? 'unknown'}`,
+  `- startup_stalled_runs: ${summary.startupStalledRuns ?? 'unknown'}`,
+  `- auth_verdict: ${summary.authVerdict ?? 'unknown'}`,
+  `- missing_user_scope: ${summary.missingUserScope ? 'yes' : 'no'}`,
+  `- workflow_lint_findings: ${summary.lintFindingsCount}`,
+  '',
+];
+
+export const buildConsumerStartupUnblockBlockerLines = (
+  summary: ConsumerStartupUnblockSummary
+): ReadonlyArray<string> => {
+  if (summary.blockers.length === 0) {
+    return ['## Blockers', '', '- none', ''];
+  }
+
+  return ['## Blockers', '', ...summary.blockers.map((blocker) => `- ${blocker}`), ''];
+};

package/scripts/consumer-startup-unblock-parser-lib.ts

@@ -0,0 +1,24 @@
+import type { ParsedWorkflowLintReport } from './consumer-startup-unblock-contract';
+import {
+  dedupeConsumerStartupUnblockValues,
+  parseConsumerStartupUnblockInteger,
+} from './consumer-startup-unblock-contract';
+
+export const parseWorkflowLintReport = (markdown: string): ParsedWorkflowLintReport => {
+  const exitCode = parseConsumerStartupUnblockInteger(
+    markdown.match(/- exit_code:\s*([0-9]+)/)?.[1]
+  );
+
+  const findings = dedupeConsumerStartupUnblockValues(
+    markdown
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => /\[[a-z-]+\]\s*$/.test(line))
+  );
+
+  return {
+    exitCode,
+    findingsCount: findings.length,
+    findings,
+  };
+};

package/scripts/consumer-startup-unblock-runner-lib.ts

@@ -0,0 +1,69 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import {
+  parseAuthReport,
+  parseSupportBundle,
+} from './consumer-support-ticket-lib';
+import type { ConsumerStartupUnblockCliOptions } from './consumer-startup-unblock-args-contract';
+import { readConsumerStartupUnblockInput } from './consumer-startup-unblock-input-lib';
+import {
+  buildConsumerStartupUnblockStatus,
+  parseWorkflowLintReport,
+  summarizeConsumerStartupUnblock,
+} from './consumer-startup-unblock-status-lib';
+
+export const buildConsumerStartupUnblockReportFromOptions = (params: {
+  cwd: string;
+  options: ConsumerStartupUnblockCliOptions;
+}): { markdown: string; verdict: string } => {
+  const supportBundle = readConsumerStartupUnblockInput(params.cwd, params.options.supportBundleFile);
+  const authReport = readConsumerStartupUnblockInput(params.cwd, params.options.authReportFile);
+  const workflowLintReport = readConsumerStartupUnblockInput(
+    params.cwd,
+    params.options.workflowLintReportFile
+  );
+
+  const parsedSupport = supportBundle.content
+    ? parseSupportBundle(supportBundle.content)
+    : undefined;
+  const parsedAuth = authReport.content ? parseAuthReport(authReport.content) : undefined;
+  const parsedWorkflowLint = workflowLintReport.content
+    ? parseWorkflowLintReport(workflowLintReport.content)
+    : undefined;
+
+  const summary = summarizeConsumerStartupUnblock({
+    hasSupportBundle: supportBundle.exists,
+    hasAuthReport: authReport.exists,
+    support: parsedSupport,
+    auth: parsedAuth,
+    workflowLint: parsedWorkflowLint,
+  });
+
+  return {
+    markdown: buildConsumerStartupUnblockStatus({
+      repo: params.options.repo,
+      supportBundlePath: params.options.supportBundleFile,
+      authReportPath: params.options.authReportFile,
+      workflowLintReportPath: params.options.workflowLintReportFile,
+      hasSupportBundle: supportBundle.exists,
+      hasAuthReport: authReport.exists,
+      hasWorkflowLintReport: workflowLintReport.exists,
+      summary,
+      support: parsedSupport,
+      auth: parsedAuth,
+      workflowLint: parsedWorkflowLint,
+    }),
+    verdict: summary.verdict,
+  };
+};
+
+export const writeConsumerStartupUnblockReport = (params: {
+  cwd: string;
+  outFile: string;
+  markdown: string;
+}): string => {
+  const outputPath = resolve(params.cwd, params.outFile);
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, params.markdown, 'utf8');
+  return outputPath;
+};

package/scripts/consumer-startup-unblock-status-lib.ts

@@ -0,0 +1,7 @@
+export type {
+  ConsumerStartupUnblockSummary,
+  ParsedWorkflowLintReport,
+} from './consumer-startup-unblock-contract';
+export { parseWorkflowLintReport } from './consumer-startup-unblock-parser-lib';
+export { summarizeConsumerStartupUnblock } from './consumer-startup-unblock-summary-lib';
+export { buildConsumerStartupUnblockStatus } from './consumer-startup-unblock-markdown-lib';

package/scripts/consumer-startup-unblock-summary-lib.ts

@@ -0,0 +1,54 @@
+import type { ParsedAuthReport, ParsedSupportBundle } from './consumer-support-ticket-parser-lib';
+import type {
+  ConsumerStartupUnblockSummary,
+  ParsedWorkflowLintReport,
+} from './consumer-startup-unblock-contract';
+import { collectConsumerStartupUnblockBlockers } from './consumer-startup-unblock-blockers-lib';
+import { hasConsumerStartupUnblockUserScopeGap } from './consumer-startup-unblock-auth-lib';
+
+export const summarizeConsumerStartupUnblock = (params: {
+  hasSupportBundle: boolean;
+  hasAuthReport: boolean;
+  support?: ParsedSupportBundle;
+  auth?: ParsedAuthReport;
+  workflowLint?: ParsedWorkflowLintReport;
+}): ConsumerStartupUnblockSummary => {
+  const blockers: string[] = [];
+  const missingInputs: string[] = [];
+
+  if (!params.hasSupportBundle) {
+    missingInputs.push('Missing support bundle report');
+  }
+  if (!params.hasAuthReport) {
+    missingInputs.push('Missing auth check report');
+  }
+
+  if (missingInputs.length > 0) {
+    return {
+      verdict: 'MISSING_INPUTS',
+      blockers: missingInputs,
+      startupFailureRuns: undefined,
+      startupStalledRuns: undefined,
+      authVerdict: params.auth?.verdict,
+      missingUserScope: hasConsumerStartupUnblockUserScopeGap(params.auth),
+      lintFindingsCount: params.workflowLint?.findingsCount ?? 0,
+    };
+  }
+
+  const summaryInputs = collectConsumerStartupUnblockBlockers({
+    support: params.support,
+    auth: params.auth,
+    workflowLint: params.workflowLint,
+  });
+  blockers.push(...summaryInputs.blockers);
+
+  return {
+    verdict: blockers.length === 0 ? 'READY_FOR_RETEST' : 'BLOCKED',
+    blockers,
+    startupFailureRuns: summaryInputs.startupFailureRuns,
+    startupStalledRuns: summaryInputs.startupStalledRuns,
+    authVerdict: summaryInputs.authVerdict,
+    missingUserScope: summaryInputs.missingUserScope,
+    lintFindingsCount: summaryInputs.lintFindingsCount,
+  };
+};

package/scripts/consumer-support-bundle-args-defaults-lib.ts

@@ -0,0 +1,11 @@
+import {
+  DEFAULT_CONSUMER_SUPPORT_BUNDLE_LIMIT,
+  DEFAULT_CONSUMER_SUPPORT_BUNDLE_OUT_FILE,
+  type ConsumerSupportBundleCliOptions,
+} from './consumer-support-bundle-contract';
+
+export const createConsumerSupportBundleDefaultOptions = (): ConsumerSupportBundleCliOptions => ({
+  repo: '',
+  limit: DEFAULT_CONSUMER_SUPPORT_BUNDLE_LIMIT,
+  outFile: DEFAULT_CONSUMER_SUPPORT_BUNDLE_OUT_FILE,
+});

package/scripts/consumer-support-bundle-args-values-lib.ts

@@ -0,0 +1,27 @@
+import type { ConsumerSupportBundleCliOptions } from './consumer-support-bundle-contract';
+
+export type ConsumerSupportBundleValueArg = '--repo' | '--limit' | '--out';
+
+export const isConsumerSupportBundleValueArg = (
+  arg: string
+): arg is ConsumerSupportBundleValueArg => arg === '--repo' || arg === '--limit' || arg === '--out';
+
+export const applyConsumerSupportBundleValueArg = (params: {
+  options: ConsumerSupportBundleCliOptions;
+  arg: ConsumerSupportBundleValueArg;
+  value: string;
+}): void => {
+  if (params.arg === '--repo') {
+    params.options.repo = params.value;
+    return;
+  }
+  if (params.arg === '--limit') {
+    const parsed = Number.parseInt(params.value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+      throw new Error(`Invalid --limit value: ${params.value}`);
+    }
+    params.options.limit = parsed;
+    return;
+  }
+  params.options.outFile = params.value;
+};

package/scripts/consumer-support-bundle-contract.ts

@@ -0,0 +1,61 @@
+export type ConsumerSupportBundleCliOptions = {
+  repo: string;
+  limit: number;
+  outFile: string;
+};
+
+export type ConsumerSupportBundleWorkflowRun = {
+  databaseId: number;
+  workflowName: string;
+  status: string;
+  conclusion: string | null;
+  url: string;
+  event: string;
+  createdAt: string;
+  headBranch: string;
+  headSha: string;
+};
+
+export type ConsumerSupportBundleRunMetadata = {
+  id: number;
+  name: string;
+  path: string;
+  status: string;
+  conclusion: string | null;
+  html_url: string;
+  referenced_workflows: ReadonlyArray<unknown>;
+};
+
+export type ConsumerSupportBundleJobsResponse = {
+  total_count: number;
+};
+
+export type ConsumerSupportBundleArtifactResponse = {
+  total_count: number;
+};
+
+export type ConsumerSupportBundleRepoResponse = {
+  full_name: string;
+  private: boolean;
+  visibility: string;
+};
+
+export type ConsumerSupportBundleRepoActionsPermissionsResponse = {
+  enabled: boolean;
+  allowed_actions: string;
+  sha_pinning_required: boolean;
+};
+
+export type ConsumerSupportBundleUserActionsBillingResponse = Record<string, unknown>;
+
+export type ConsumerSupportBundleRunDiagnostic = {
+  run: ConsumerSupportBundleWorkflowRun;
+  metadata?: ConsumerSupportBundleRunMetadata;
+  jobsCount?: number;
+  artifactsCount?: number;
+  error?: string;
+};
+
+export const DEFAULT_CONSUMER_SUPPORT_BUNDLE_LIMIT = 20;
+export const DEFAULT_CONSUMER_SUPPORT_BUNDLE_OUT_FILE =
+  '.audit-reports/consumer-triage/consumer-startup-failure-support-bundle.md';

package/scripts/consumer-support-bundle-gh-auth-repo-lib.ts

@@ -0,0 +1,51 @@
+import type {
+  ConsumerSupportBundleGhResult,
+} from './consumer-support-bundle-gh-command-lib';
+import type {
+  ConsumerSupportBundleRepoActionsPermissionsResponse,
+  ConsumerSupportBundleRepoResponse,
+  ConsumerSupportBundleUserActionsBillingResponse,
+} from './consumer-support-bundle-contract';
+import { tryRunGh, tryRunGhJson } from './consumer-support-bundle-gh-command-lib';
+import { extractRepoOwner } from './consumer-startup-failure-support-bundle-lib';
+
+export const ensureConsumerSupportBundleAuth = (): string => {
+  const auth = tryRunGh(['auth', 'status']);
+  if (!auth.ok) {
+    throw new Error(`gh auth status failed: ${auth.error}`);
+  }
+
+  return auth.output ?? '';
+};
+
+export const loadConsumerSupportBundleRepoInfo = (
+  repo: string
+): ConsumerSupportBundleGhResult<ConsumerSupportBundleRepoResponse> => {
+  return tryRunGhJson<ConsumerSupportBundleRepoResponse>(['api', `repos/${repo}`]);
+};
+
+export const loadConsumerSupportBundleActionsPermissions = (
+  repo: string
+): ConsumerSupportBundleGhResult<ConsumerSupportBundleRepoActionsPermissionsResponse> => {
+  return tryRunGhJson<ConsumerSupportBundleRepoActionsPermissionsResponse>([
+    'api',
+    `repos/${repo}/actions/permissions`,
+  ]);
+};
+
+export const loadConsumerSupportBundleBillingInfo = (
+  repo: string
+): ConsumerSupportBundleGhResult<ConsumerSupportBundleUserActionsBillingResponse> => {
+  const owner = extractRepoOwner(repo);
+  if (!owner) {
+    return {
+      ok: false,
+      error: 'Unable to detect repository owner for billing probe (expected owner/repo).',
+    };
+  }
+
+  return tryRunGhJson<ConsumerSupportBundleUserActionsBillingResponse>([
+    'api',
+    `users/${owner}/settings/billing/actions`,
+  ]);
+};