@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/operations/services/github-actions-verification.js

@@ -1,589 +0,0 @@
-import { Buffer } from "node:buffer";
-import {
-  createGitHubApiClient,
-  parseGitHubRepositorySlug
-} from "./github-api.js";
-function normalizeWorkflowRun(run) {
-  return {
-    id: Number(run.id ?? 0),
-    status: typeof run.status === "string" ? run.status : null,
-    conclusion: typeof run.conclusion === "string" ? run.conclusion : null,
-    url: typeof run.html_url === "string" ? run.html_url : null,
-    headSha: typeof run.head_sha === "string" ? run.head_sha : null,
-    headBranch: typeof run.head_branch === "string" ? run.head_branch : null,
-    createdAt: typeof run.created_at === "string" ? run.created_at : null,
-    updatedAt: typeof run.updated_at === "string" ? run.updated_at : null
-  };
-}
-function normalizeWorkflowJobStep(step) {
-  return {
-    name: String(step.name ?? ""),
-    number: typeof step.number === "number" ? step.number : null,
-    status: typeof step.status === "string" ? step.status : null,
-    conclusion: typeof step.conclusion === "string" ? step.conclusion : null,
-    startedAt: typeof step.started_at === "string" ? step.started_at : null,
-    completedAt: typeof step.completed_at === "string" ? step.completed_at : null
-  };
-}
-function isSuccessfulConclusion(conclusion) {
-  return conclusion === "success" || conclusion === "skipped" || conclusion === "neutral";
-}
-function isFailedConclusion(conclusion) {
-  return Boolean(conclusion && !isSuccessfulConclusion(conclusion));
-}
-function normalizeWorkflowJob(job) {
-  const steps = Array.isArray(job.steps) ? job.steps.map((step) => normalizeWorkflowJobStep(step)) : [];
-  return {
-    id: Number(job.id ?? 0),
-    name: String(job.name ?? ""),
-    status: typeof job.status === "string" ? job.status : null,
-    conclusion: typeof job.conclusion === "string" ? job.conclusion : null,
-    url: typeof job.html_url === "string" ? job.html_url : null,
-    steps,
-    failedSteps: steps.filter((step) => isFailedConclusion(step.conclusion))
-  };
-}
-function workflowStateForRun(run) {
-  if (!run) return "missing";
-  if (run.status !== "completed") return "pending";
-  return isSuccessfulConclusion(run.conclusion) ? "success" : "failure";
-}
-function aggregateWorkflowState(states) {
-  if (states.includes("error")) return "error";
-  if (states.includes("not_pushed")) return "not_pushed";
-  if (states.includes("failure")) return "failure";
-  if (states.includes("missing")) return "missing";
-  if (states.includes("pending")) return "pending";
-  return "success";
-}
-function cappedLogExcerpt(value, maxLines) {
-  const text = typeof value === "string" ? value : value instanceof Uint8Array ? Buffer.from(value).toString("utf8") : Buffer.isBuffer(value) ? value.toString("utf8") : String(value ?? "");
-  const lines = text.split(/\r?\n/u);
-  return lines.slice(Math.max(0, lines.length - maxLines)).join("\n").trim();
-}
-async function downloadJobLogExcerpt(client, repository, jobId, maxLines) {
-  const { owner, name } = parseGitHubRepositorySlug(repository);
-  const response = await client.request("GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs", {
-    owner,
-    repo: name,
-    job_id: jobId
-  });
-  return cappedLogExcerpt(response.data, maxLines);
-}
-async function loadWorkflowJobs(client, repository, runId, options) {
-  const { owner, name } = parseGitHubRepositorySlug(repository);
-  const jobs = await client.rest.actions.listJobsForWorkflowRun({
-    owner,
-    repo: name,
-    run_id: runId,
-    per_page: 100
-  });
-  const normalized = jobs.data.jobs.map((job) => normalizeWorkflowJob(job));
-  if (!options.includeLogs) {
-    return normalized;
-  }
-  await Promise.all(normalized.filter((job) => isFailedConclusion(job.conclusion) && job.id > 0).map(async (job) => {
-    try {
-      job.logExcerpt = await downloadJobLogExcerpt(client, repository, job.id, options.logLines);
-    } catch (error) {
-      job.logExcerpt = `Unable to fetch job log: ${error instanceof Error ? error.message : String(error)}`;
-    }
-  }));
-  return normalized;
-}
-async function resolveRemoteBranchHead(client, repository, branch) {
-  const { owner, name } = parseGitHubRepositorySlug(repository);
-  const remote = await client.rest.repos.getBranch({
-    owner,
-    repo: name,
-    branch
-  });
-  return remote.data.commit.sha;
-}
-async function findWorkflowRun(client, repository, workflow, branch, headSha) {
-  const { owner, name } = parseGitHubRepositorySlug(repository);
-  const listed = await client.rest.actions.listWorkflowRuns({
-    owner,
-    repo: name,
-    workflow_id: workflow,
-    branch: branch ?? void 0,
-    head_sha: headSha ?? void 0,
-    per_page: 20
-  });
-  const runs = listed.data.workflow_runs.map((run) => normalizeWorkflowRun(run)).filter((run) => (!headSha || run.headSha === headSha) && (!branch || run.headBranch === branch));
-  return runs[0] ?? null;
-}
-function inspectCommand(repository, runId) {
-  return repository && runId ? `gh run view ${runId} --repo ${repository} --log-failed` : null;
-}
-function workflowMessage(workflow, state, conclusion) {
-  switch (state) {
-    case "success":
-      return `${workflow} completed successfully.`;
-    case "failure":
-      return `${workflow} completed with conclusion ${conclusion ?? "unknown"}.`;
-    case "pending":
-      return `${workflow} is still running or queued.`;
-    case "missing":
-      return `${workflow} has no run for this branch HEAD.`;
-    case "not_pushed":
-      return `${workflow} cannot be checked because the local HEAD is not the remote branch HEAD.`;
-    case "error":
-      return `${workflow} could not be inspected.`;
-  }
-}
-function isGitHubNotFoundError(error) {
-  const status = typeof error?.status === "number" ? Number(error.status) : null;
-  const message = error instanceof Error ? error.message : String(error ?? "");
-  return status === 404 || /not found/iu.test(message);
-}
-async function inspectWorkflow(client, target, workflow, options) {
-  if (!target.repository || !target.branch || !target.headSha) {
-    return {
-      workflow,
-      state: "error",
-      status: null,
-      conclusion: null,
-      runId: null,
-      url: null,
-      headSha: target.headSha,
-      branch: target.branch,
-      createdAt: null,
-      updatedAt: null,
-      jobs: [],
-      failedJobs: [],
-      inspectCommand: null,
-      message: "Repository, branch, or head SHA is unavailable."
-    };
-  }
-  try {
-    const run = await findWorkflowRun(client, target.repository, workflow, target.branch, target.headSha);
-    const state = workflowStateForRun(run);
-    const jobs = run?.id && run.status === "completed" ? await loadWorkflowJobs(client, target.repository, run.id, options) : [];
-    const failedJobs = jobs.filter((job) => isFailedConclusion(job.conclusion));
-    return {
-      workflow,
-      state,
-      status: run?.status ?? null,
-      conclusion: run?.conclusion ?? null,
-      runId: run?.id ?? null,
-      url: run?.url ?? null,
-      headSha: run?.headSha ?? target.headSha,
-      branch: run?.headBranch ?? target.branch,
-      createdAt: run?.createdAt ?? null,
-      updatedAt: run?.updatedAt ?? null,
-      jobs,
-      failedJobs,
-      inspectCommand: inspectCommand(target.repository, run?.id ?? null),
-      message: workflowMessage(workflow, state, run?.conclusion ?? null)
-    };
-  } catch (error) {
-    if (isGitHubNotFoundError(error)) {
-      return {
-        workflow,
-        state: "missing",
-        status: null,
-        conclusion: null,
-        runId: null,
-        url: null,
-        headSha: target.headSha,
-        branch: target.branch,
-        createdAt: null,
-        updatedAt: null,
-        jobs: [],
-        failedJobs: [],
-        inspectCommand: null,
-        message: `${workflow} is missing or has no run for this branch HEAD.`
-      };
-    }
-    return {
-      workflow,
-      state: "error",
-      status: null,
-      conclusion: null,
-      runId: null,
-      url: null,
-      headSha: target.headSha,
-      branch: target.branch,
-      createdAt: null,
-      updatedAt: null,
-      jobs: [],
-      failedJobs: [],
-      inspectCommand: null,
-      message: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-function repositoryFailure(target) {
-  return {
-    type: "repository",
-    repository: target.repository,
-    repoName: target.name,
-    workflow: null,
-    runId: null,
-    jobId: null,
-    jobName: null,
-    state: target.state,
-    conclusion: null,
-    url: null,
-    inspectCommand: null,
-    message: target.message ?? `${target.name} requires attention.`,
-    failedSteps: []
-  };
-}
-function workflowFailure(repo, workflow) {
-  return {
-    type: "workflow",
-    repository: repo.repository,
-    repoName: repo.name,
-    workflow: workflow.workflow,
-    runId: workflow.runId,
-    jobId: null,
-    jobName: null,
-    state: workflow.state,
-    conclusion: workflow.conclusion,
-    url: workflow.url,
-    inspectCommand: workflow.inspectCommand,
-    message: workflow.message ?? `${repo.name} ${workflow.workflow} requires attention.`,
-    failedSteps: []
-  };
-}
-function jobFailure(repo, workflow, job) {
-  return {
-    type: "job",
-    repository: repo.repository,
-    repoName: repo.name,
-    workflow: workflow.workflow,
-    runId: workflow.runId,
-    jobId: job.id,
-    jobName: job.name,
-    state: workflow.state,
-    conclusion: job.conclusion,
-    url: job.url ?? workflow.url,
-    inspectCommand: workflow.inspectCommand,
-    message: `${repo.name} ${workflow.workflow} job ${job.name || job.id} completed with conclusion ${job.conclusion ?? "unknown"}.`,
-    failedSteps: job.failedSteps,
-    logExcerpt: job.logExcerpt ?? null
-  };
-}
-function collectFailures(repositories) {
-  const failures = [];
-  for (const repo of repositories) {
-    if (repo.state === "not_pushed" || repo.state === "error") {
-      failures.push(repositoryFailure(repo));
-      continue;
-    }
-    for (const workflow of repo.workflows) {
-      if (workflow.state === "failure" && workflow.failedJobs.length > 0) {
-        failures.push(...workflow.failedJobs.map((job) => jobFailure(repo, workflow, job)));
-        continue;
-      }
-      if (workflow.state === "missing" && !repo.missingIsFailure) {
-        continue;
-      }
-      if (workflow.state === "failure" || workflow.state === "missing" || workflow.state === "error") {
-        failures.push(workflowFailure(repo, workflow));
-      }
-    }
-  }
-  return failures;
-}
-function summarize(repositories, failures) {
-  const workflows = repositories.flatMap((repo) => repo.workflows);
-  return {
-    repositories: repositories.length,
-    workflows: workflows.length,
-    success: workflows.filter((workflow) => workflow.state === "success").length,
-    failure: workflows.filter((workflow) => workflow.state === "failure").length,
-    pending: workflows.filter((workflow) => workflow.state === "pending").length,
-    missing: workflows.filter((workflow) => workflow.state === "missing").length,
-    notPushed: repositories.filter((repo) => repo.state === "not_pushed").length,
-    error: workflows.filter((workflow) => workflow.state === "error").length + repositories.filter((repo) => repo.state === "error").length,
-    failures: failures.length
-  };
-}
-async function inspectTarget(client, target, options) {
-  if (!target.repository || !target.branch || !target.headSha) {
-    return {
-      name: target.name,
-      repoPath: target.repoPath,
-      repository: target.repository,
-      kind: target.kind ?? "package",
-      branch: target.branch,
-      headSha: target.headSha,
-      remoteHeadSha: null,
-      remoteSynced: false,
-      state: "error",
-      message: "Repository, branch, or head SHA is unavailable.",
-      workflows: [],
-      missingIsFailure: target.missingIsFailure ?? true
-    };
-  }
-  const missingIsFailure = target.missingIsFailure ?? true;
-  try {
-    const remoteHeadSha = await resolveRemoteBranchHead(client, target.repository, target.branch);
-    if (remoteHeadSha !== target.headSha) {
-      return {
-        name: target.name,
-        repoPath: target.repoPath,
-        repository: target.repository,
-        kind: target.kind ?? "package",
-        branch: target.branch,
-        headSha: target.headSha,
-        remoteHeadSha,
-        remoteSynced: false,
-        state: "not_pushed",
-        message: `Local HEAD ${target.headSha.slice(0, 12)} does not match origin/${target.branch} ${remoteHeadSha.slice(0, 12)}.`,
-        missingIsFailure,
-        workflows: target.workflows.map((workflow) => ({
-          workflow,
-          state: "not_pushed",
-          status: null,
-          conclusion: null,
-          runId: null,
-          url: null,
-          headSha: target.headSha,
-          branch: target.branch,
-          createdAt: null,
-          updatedAt: null,
-          jobs: [],
-          failedJobs: [],
-          inspectCommand: null,
-          message: workflowMessage(workflow, "not_pushed", null)
-        }))
-      };
-    }
-    const workflows = await Promise.all(target.workflows.map((workflow) => inspectWorkflow(client, target, workflow, options)));
-    return {
-      name: target.name,
-      repoPath: target.repoPath,
-      repository: target.repository,
-      kind: target.kind ?? "package",
-      branch: target.branch,
-      headSha: target.headSha,
-      remoteHeadSha,
-      remoteSynced: true,
-      state: aggregateWorkflowState(workflows.map((workflow) => workflow.state)),
-      message: null,
-      workflows,
-      missingIsFailure
-    };
-  } catch (error) {
-    return {
-      name: target.name,
-      repoPath: target.repoPath,
-      repository: target.repository,
-      kind: target.kind ?? "package",
-      branch: target.branch,
-      headSha: target.headSha,
-      remoteHeadSha: null,
-      remoteSynced: false,
-      state: "error",
-      message: error instanceof Error ? error.message : String(error),
-      workflows: [],
-      missingIsFailure
-    };
-  }
-}
-async function inspectGitHubActionsVerification(targets, {
-  client = createGitHubApiClient(),
-  includeLogs = false,
-  logLines = 120
-} = {}) {
-  const resolvedLogLines = Math.max(20, Math.min(1e3, Math.floor(logLines)));
-  const repositories = await Promise.all(targets.map((target) => inspectTarget(client, target, {
-    includeLogs,
-    logLines: resolvedLogLines
-  })));
-  const failures = collectFailures(repositories);
-  return {
-    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    repositories,
-    failures,
-    summary: summarize(repositories, failures)
-  };
-}
-function skippedGitHubActionsGate(gate, reason) {
-  return {
-    name: gate.name,
-    repository: gate.repository ?? null,
-    workflow: gate.workflow,
-    branch: gate.branch,
-    headSha: gate.headSha,
-    status: "skipped",
-    reason,
-    conclusion: null,
-    runId: null,
-    url: null,
-    createdAt: null,
-    updatedAt: null,
-    timeoutSeconds: gate.timeoutSeconds ?? null,
-    cached: false
-  };
-}
-function formatGitHubActionsGateFailure(gate, result) {
-  const repository = String(result.repository ?? gate.repository ?? gate.name);
-  const runId = typeof result.runId === "number" || typeof result.runId === "string" ? String(result.runId) : "";
-  const url = typeof result.url === "string" && result.url ? `
-${result.url}` : "";
-  const failedJobs = Array.isArray(result.failedJobs) ? result.failedJobs.map((job) => typeof job?.name === "string" ? String(job.name) : "").filter(Boolean) : [];
-  const jobLine = failedJobs.length > 0 ? `
-Failed jobs: ${failedJobs.join(", ")}` : "";
-  const command = runId ? `
-Inspect with: gh run view ${runId} --repo ${repository} --log-failed` : "";
-  return `${gate.name} ${gate.workflow} completed with conclusion ${String(result.conclusion ?? "unknown")} in ${repository}.${url}${jobLine}${command}`;
-}
-function isRetryableGitHubActionsSetupFailure(result) {
-  const failedJobs = Array.isArray(result.failedJobs) ? result.failedJobs : [];
-  return failedJobs.length > 0 && failedJobs.every((job) => {
-    const steps = Array.isArray(job.steps) ? job.steps : [];
-    return steps.length === 1 && steps[0]?.name === "Set up job" && steps[0]?.conclusion === "failure";
-  });
-}
-async function rerunGitHubActionsFailedJobs(result, env = process.env) {
-  const repository = String(result.repository ?? "");
-  const runId = Number(result.runId);
-  if (!repository || !Number.isSafeInteger(runId) || runId <= 0) {
-    throw new Error("Cannot retry GitHub Actions setup failure without a repository and run ID.");
-  }
-  const { owner, name: repo } = parseGitHubRepositorySlug(repository);
-  const client = createGitHubApiClient({ env });
-  await client.request("POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun-failed-jobs", {
-    owner,
-    repo,
-    run_id: runId
-  });
-  return { repository, runId };
-}
-function formatElapsed(seconds) {
-  const safe = Math.max(0, Math.round(seconds));
-  if (safe < 60) return `${safe}s`;
-  const minutes = Math.floor(safe / 60);
-  const remainder = safe % 60;
-  return remainder === 0 ? `${minutes}m` : `${minutes}m${remainder}s`;
-}
-function shortSha(value) {
-  return value ? value.slice(0, 12) : "(unknown)";
-}
-function activeJobSummaries(event) {
-  const activeJobs = event.activeJobs ?? [];
-  return activeJobs.slice(0, 2).map((job) => {
-    const activeStep = (job.steps ?? []).find((step) => step.status && step.status !== "completed");
-    return activeStep?.name ? `${job.name} > ${activeStep.name}` : job.name;
-  }).filter(Boolean);
-}
-function activeJobSummary(event) {
-  const summaries = activeJobSummaries(event);
-  return summaries.length > 0 ? `; active: ${summaries.join(", ")}` : "";
-}
-function failedJobSummary(event) {
-  const failedJobs = event.failedJobs ?? [];
-  if (failedJobs.length === 0) return "";
-  const names = failedJobs.slice(0, 3).map((job) => job.name).filter(Boolean);
-  return names.length > 0 ? `; failed: ${names.join(", ")}` : "";
-}
-function formatGitHubActionsGateProgress(gate, event, operation) {
-  const prefix = `[${operation}][gate][${gate.name}] ${event.workflow}`;
-  if (event.type === "waiting") {
-    return `${prefix} on ${event.branch ?? gate.branch}: waiting for run for ${shortSha(event.headSha ?? gate.headSha)} (${formatElapsed(event.elapsedSeconds)} elapsed)`;
-  }
-  if (event.type === "completed") {
-    const conclusion = event.conclusion === "success" ? "successfully" : `with conclusion ${event.conclusion ?? "unknown"}`;
-    const url2 = event.url ? `: ${event.url}` : "";
-    return `${prefix} completed ${conclusion}${failedJobSummary(event)} in ${formatElapsed(event.elapsedSeconds)}${url2}`;
-  }
-  const status = event.status ?? "waiting";
-  const url = event.url ? `: ${event.url}` : "";
-  const run = event.runId ? ` run ${event.runId}` : "";
-  return `${prefix}${run} ${status}${activeJobSummary(event)}${url} (${formatElapsed(event.elapsedSeconds)} elapsed)`;
-}
-function progressCompactKey(gate, event) {
-  const active = activeJobSummaries(event).join(",");
-  return [
-    gate.name,
-    event.workflow,
-    event.runId ?? "none",
-    event.type,
-    event.status ?? "none",
-    event.conclusion ?? "none",
-    active
-  ].join("|");
-}
-function formatCompactedGitHubActionsGateProgress(gate, event, operation, repeatedPolls, lastChangeSeconds) {
-  const prefix = `[${operation}][gate][${gate.name}] ${event.workflow}`;
-  const run = event.runId ? ` run ${event.runId}` : "";
-  const active = activeJobSummaries(event);
-  const activeText = active.length > 0 ? active.join(", ") : event.status ?? "waiting";
-  const url = event.url ? `: ${event.url}` : "";
-  return `${prefix}${run} still active: ${activeText} (${repeatedPolls} polls, ${formatElapsed(lastChangeSeconds)} since last change)${url}`;
-}
-function createGitHubActionsGateProgressReporter(gate, options = {}) {
-  const operation = options.operation ?? "workflow";
-  const now = options.now ?? (() => Date.now());
-  const minRepeatMs = options.minRepeatMs ?? 6e4;
-  let lastKey = null;
-  let lastChangeAt = now();
-  let lastEmitAt = 0;
-  let repeatedPolls = 0;
-  return (event) => {
-    if (event.type === "completed") {
-      options.onProgress?.(formatGitHubActionsGateProgress(gate, event, operation));
-      lastKey = null;
-      repeatedPolls = 0;
-      lastEmitAt = now();
-      lastChangeAt = lastEmitAt;
-      return;
-    }
-    const currentKey = progressCompactKey(gate, event);
-    const currentTime = now();
-    if (currentKey !== lastKey) {
-      lastKey = currentKey;
-      lastChangeAt = currentTime;
-      lastEmitAt = currentTime;
-      repeatedPolls = 0;
-      options.onProgress?.(formatGitHubActionsGateProgress(gate, event, operation));
-      return;
-    }
-    repeatedPolls += 1;
-    if (currentTime - lastEmitAt >= minRepeatMs) {
-      options.onProgress?.(formatCompactedGitHubActionsGateProgress(
-        gate,
-        event,
-        operation,
-        repeatedPolls,
-        Math.max(0, Math.round((currentTime - lastChangeAt) / 1e3))
-      ));
-      lastEmitAt = currentTime;
-      repeatedPolls = 0;
-    }
-  };
-}
-async function waitForGitHubActionsGate(gate, options = {}) {
-  const { waitForGitHubWorkflowCompletion } = await import("./github-automation.js");
-  const reportProgress = createGitHubActionsGateProgressReporter(gate, {
-    operation: options.operation ?? "workflow",
-    onProgress: options.onProgress
-  });
-  return await waitForGitHubWorkflowCompletion(gate.repoPath, {
-    repository: gate.repository,
-    workflow: gate.workflow,
-    headSha: gate.headSha,
-    branch: gate.branch,
-    timeoutSeconds: gate.timeoutSeconds ?? options.timeoutSeconds,
-    pollSeconds: gate.pollSeconds ?? options.pollSeconds,
-    dispatchIfMissing: gate.dispatchIfMissing ?? gate.workflow === "verify.yml",
-    dispatchAfterSeconds: gate.dispatchAfterSeconds ?? 75,
-    dispatchInputs: gate.dispatchInputs,
-    env: options.env,
-    onProgress: reportProgress
-  });
-}
-export {
-  createGitHubActionsGateProgressReporter,
-  formatGitHubActionsGateFailure,
-  inspectGitHubActionsVerification,
-  isRetryableGitHubActionsSetupFailure,
-  rerunGitHubActionsFailedJobs,
-  skippedGitHubActionsGate,
-  waitForGitHubActionsGate
-};