create-interview-cockpit 0.18.0 → 0.19.0

package/template/server/src/gha-runner.ts

@@ -17,8 +17,51 @@ interface GithubActionsLabWorkspace {
 
 type OutputKind = "stdout" | "stderr" | "info";
 
+// Status a job can be in across the lifecycle of one act run.
+// `pending`   — declared in the workflow YAML but not yet started
+// `running`   — act has emitted its first line for this job
+// `success`   — act printed "Job succeeded" (or run finished cleanly while job was running)
+// `failed`    — act printed "Job failed" (or run finished non-zero while job was running)
+// `skipped`   — act printed a skip line
+export type GhaJobStatus =
+  | "pending"
+  | "running"
+  | "success"
+  | "failed"
+  | "skipped";
+
+export interface GhaStepSnapshot {
+  // Step name as printed by act (e.g. "Checkout repo").
+  name: string;
+  // "Main" for normal steps, "Pre"/"Post" for action lifecycle hooks.
+  phase: "Main" | "Pre" | "Post";
+  status: GhaJobStatus;
+  startedAt?: string;
+  endedAt?: string;
+  durationMs?: number;
+  // Captured raw lines that appeared between this step's start and its
+  // terminal marker. Capped per-step so a runaway step can't bloat the
+  // metadata file.
+  log?: string;
+}
+
+export interface GhaJobSnapshot {
+  // Job key as `act` prints it inside the [workflow/job] prefix.
+  // For matrix jobs this includes the matrix instance suffix.
+  name: string;
+  // Workflow display name from the prefix (left of the slash).
+  workflow?: string;
+  status: GhaJobStatus;
+  startedAt?: string;
+  endedAt?: string;
+  durationMs?: number;
+  // Per-step lifecycle parsed from act's `⭐ Run` / `✅ Success` markers.
+  steps?: GhaStepSnapshot[];
+}
+
 export type GhaStreamMessage =
   | { type: "output"; kind: OutputKind; text: string }
+  | { type: "job"; job: GhaJobSnapshot }
   | { type: "complete"; runId: string; exitCode: number; durationMs: number }
   | { type: "error"; error: string };
 
@@ -362,6 +405,273 @@ export interface GhaRunMetadata {
   durationMs: number;
   exitCode: number;
   error?: string;
+  // Parsed live from act's stdout; lets the UI render a job DAG with
+  // pending/running/success/failed boxes instead of just raw text.
+  jobs?: GhaJobSnapshot[];
+  // Captured for the History tab so users can group runs by workflow.
+  event?: string;
+  workflow?: string;
+}
+
+// ─── act output → job snapshot parser ───────────────────────────────────
+//
+// act prints every line for a given job with a `[<workflow>/<job>]` prefix,
+// e.g.:
+//   [CI/greet      ] 🚀  Start  image=catthehacker/ubuntu:act-latest
+//   [CI/greet      ]   ✅  Success - Set up job
+//   [CI/greet      ] 🏁  Job succeeded
+//   [CI/build-1    ] 🏁  Job failed
+// We watch for the first line per job (→ running), and the "Job succeeded /
+// Job failed / Job skipped" markers. Anything still running when act exits
+// is finalised based on the process exit code.
+const JOB_PREFIX_RE = /^\[([^\]/]+)\/([^\]]+)\]\s*(.*)$/;
+// act prints `⭐ Run Main <step name>` to mark a step boundary. The emoji is
+// optional in some act versions / when colour is stripped, so the regex
+// tolerates either form.
+const STEP_START_RE = /(?:⭐\s*)?Run\s+(Main|Pre|Post)\s+(.+?)\s*$/;
+// And one of these for the terminal marker:
+//   ✅  Success - Main <name>
+//   ❌  Failure - Main <name>
+//   ⏭  Skipped - Main <name>   (also ⚠)
+const STEP_END_RE =
+  /(?:[✅❌⏭⚠]\s*)?(Success|Failure|Skipped)\s*-\s*(Main|Pre|Post)\s+(.+?)\s*$/;
+const MAX_STEP_LOG_CHARS = 8_000;
+
+class JobTracker {
+  private readonly jobs = new Map<string, GhaJobSnapshot>();
+  private leftover = "";
+
+  constructor(private readonly onUpdate: (job: GhaJobSnapshot) => void) {}
+
+  feed(text: string): void {
+    const combined = this.leftover + text;
+    const lines = combined.split(/\r?\n/);
+    this.leftover = lines.pop() ?? "";
+    for (const line of lines) this.processLine(line);
+  }
+
+  flush(): void {
+    if (this.leftover) {
+      this.processLine(this.leftover);
+      this.leftover = "";
+    }
+  }
+
+  finalize(exitCode: number): void {
+    const fallback: GhaJobStatus = exitCode === 0 ? "success" : "failed";
+    const endedAt = new Date().toISOString();
+    for (const job of this.jobs.values()) {
+      // Close any still-open step first so the UI doesn't show a stuck
+      // "running" spinner inside a finished job.
+      if (job.steps) {
+        for (const step of job.steps) {
+          if (step.status === "running") {
+            step.status = fallback;
+            step.endedAt = endedAt;
+            if (step.startedAt) {
+              step.durationMs =
+                new Date(endedAt).getTime() -
+                new Date(step.startedAt).getTime();
+            }
+          }
+        }
+      }
+      if (job.status === "running") {
+        job.status = fallback;
+        job.endedAt = endedAt;
+        if (job.startedAt) {
+          job.durationMs =
+            new Date(endedAt).getTime() - new Date(job.startedAt).getTime();
+        }
+        this.onUpdate({ ...job });
+      }
+    }
+  }
+
+  snapshot(): GhaJobSnapshot[] {
+    return Array.from(this.jobs.values()).map((job) => ({
+      ...job,
+      steps: job.steps?.map((s) => ({ ...s })),
+    }));
+  }
+
+  private processLine(line: string): void {
+    const match = JOB_PREFIX_RE.exec(line);
+    if (!match) return;
+    const workflow = match[1].trim();
+    const jobName = match[2].trim();
+    const rest = match[3] ?? "";
+    if (!jobName) return;
+
+    const existing = this.jobs.get(jobName);
+    const now = new Date().toISOString();
+    const job: GhaJobSnapshot = existing
+      ? { ...existing, steps: existing.steps ? [...existing.steps] : [] }
+      : {
+          name: jobName,
+          workflow,
+          status: "running",
+          startedAt: now,
+          steps: [],
+        };
+
+    let touched = !existing; // first sighting always counts as an update
+
+    // ── Step boundaries ──
+    const stepStart = STEP_START_RE.exec(rest);
+    const stepEnd = STEP_END_RE.exec(rest);
+    if (stepEnd) {
+      const phase = stepEnd[2] as "Main" | "Pre" | "Post";
+      const name = stepEnd[3];
+      const status: GhaJobStatus =
+        stepEnd[1] === "Success"
+          ? "success"
+          : stepEnd[1] === "Failure"
+            ? "failed"
+            : "skipped";
+      const step =
+        job.steps?.find((s) => s.phase === phase && s.name === name) ?? null;
+      if (step) {
+        step.status = status;
+        step.endedAt = now;
+        if (step.startedAt) {
+          step.durationMs =
+            new Date(now).getTime() - new Date(step.startedAt).getTime();
+        }
+      } else {
+        // End without a matching start (act sometimes elides start lines
+        // for fast steps). Synthesize a zero-duration entry so the UI
+        // still shows the step.
+        job.steps?.push({ name, phase, status, endedAt: now });
+      }
+      touched = true;
+    } else if (stepStart) {
+      const phase = stepStart[1] as "Main" | "Pre" | "Post";
+      const name = stepStart[2];
+      // De-dupe: if a previous run already opened this same step, just
+      // restart it (matrix jobs share the parser instance per name).
+      const existingStep = job.steps?.find(
+        (s) => s.phase === phase && s.name === name && s.status === "running",
+      );
+      if (!existingStep) {
+        job.steps?.push({
+          name,
+          phase,
+          status: "running",
+          startedAt: now,
+          log: "",
+        });
+      }
+      touched = true;
+    } else if (job.steps && job.steps.length) {
+      // Non-marker content → belongs to the currently running step (if any),
+      // so the user can drill into the per-step log just like GitHub.
+      const current = [...job.steps]
+        .reverse()
+        .find((s) => s.status === "running");
+      if (current && rest.trim()) {
+        const stripped = rest.replace(/^[|\s]+/, "");
+        const next = `${current.log ?? ""}${stripped}\n`;
+        current.log =
+          next.length > MAX_STEP_LOG_CHARS
+            ? next.slice(0, MAX_STEP_LOG_CHARS) + "\n[step log truncated]\n"
+            : next;
+      }
+    }
+
+    // ── Job terminal markers — act always prints these once per job. ──
+    if (/Job succeeded\b/i.test(rest)) {
+      job.status = "success";
+      job.endedAt = now;
+      touched = true;
+    } else if (/Job failed\b/i.test(rest)) {
+      job.status = "failed";
+      job.endedAt = now;
+      touched = true;
+    } else if (/Job skipped\b/i.test(rest)) {
+      job.status = "skipped";
+      job.endedAt = now;
+      touched = true;
+    } else if (!existing) {
+      job.status = "running";
+    }
+
+    if (job.startedAt && job.endedAt) {
+      job.durationMs =
+        new Date(job.endedAt).getTime() - new Date(job.startedAt).getTime();
+    }
+
+    if (!touched) {
+      // Pure mid-step log line — we already mutated the step buffer above,
+      // but we still want the UI to refresh so the step log grows live.
+      this.jobs.set(jobName, job);
+      this.onUpdate({ ...job, steps: job.steps?.map((s) => ({ ...s })) });
+      return;
+    }
+
+    this.jobs.set(jobName, job);
+    this.onUpdate({ ...job, steps: job.steps?.map((s) => ({ ...s })) });
+  }
+}
+
+// ─── Run history listing ────────────────────────────────────────────────
+
+export interface GhaRunListOptions {
+  questionId?: string;
+  fileId?: string;
+  limit?: number;
+}
+
+async function readRunMetadata(
+  runId: string,
+): Promise<GhaRunMetadata | undefined> {
+  const file = path.join(getGhaRunsDir(), runId, "metadata.json");
+  const raw = await readJsonFile(file);
+  if (!raw || typeof raw !== "object") return undefined;
+  return raw as GhaRunMetadata;
+}
+
+export async function listGhaRuns(
+  options: GhaRunListOptions = {},
+): Promise<GhaRunMetadata[]> {
+  const dir = getGhaRunsDir();
+  let entries: string[] = [];
+  try {
+    entries = await fs.readdir(dir);
+  } catch (err: any) {
+    if (err?.code === "ENOENT") return [];
+    throw err;
+  }
+  const limit = Math.max(1, Math.min(options.limit ?? 50, 200));
+  const results: GhaRunMetadata[] = [];
+  for (const entry of entries) {
+    const meta = await readRunMetadata(entry);
+    if (!meta) continue;
+    if (options.fileId && meta.fileId !== options.fileId) continue;
+    if (options.questionId && meta.questionId !== options.questionId) continue;
+    results.push(meta);
+  }
+  results.sort((a, b) => (a.startedAt < b.startedAt ? 1 : -1));
+  return results.slice(0, limit);
+}
+
+export interface GhaRunDetails extends GhaRunMetadata {
+  log: string;
+}
+
+export async function getGhaRun(runId: string): Promise<GhaRunDetails> {
+  const meta = await readRunMetadata(runId);
+  if (!meta) throw new Error("Run not found");
+  let log = "";
+  try {
+    log = await fs.readFile(
+      path.join(getGhaRunsDir(), runId, "run.log"),
+      "utf8",
+    );
+  } catch {
+    // log file may have been pruned; surface metadata only
+  }
+  return { ...meta, log };
 }
 
 export async function streamGhaCommand(
@@ -386,6 +696,10 @@ export async function streamGhaCommand(
   const emit = (msg: GhaStreamMessage) => input.onMessage?.(msg);
   emit({ type: "output", kind: "info", text: parsed.displayCommand });
 
+  // Track per-job status from act's prefixed stdout/stderr lines so the
+  // client can render a live DAG in addition to the raw console.
+  const tracker = new JobTracker((job) => emit({ type: "job", job }));
+
   const child = spawn("act", parsed.args, {
     cwd: workspaceDir,
     env: {
@@ -407,11 +721,13 @@ export async function streamGhaCommand(
     child.stdout.on("data", (chunk: Buffer) => {
       const text = stripAnsi(chunk.toString());
       logs = appendLog(logs, text);
+      tracker.feed(text);
       emit({ type: "output", kind: "stdout", text });
     });
     child.stderr.on("data", (chunk: Buffer) => {
       const text = stripAnsi(chunk.toString());
       logs = appendLog(logs, text);
+      tracker.feed(text);
       emit({ type: "output", kind: "stderr", text });
     });
     child.on("error", (err: NodeJS.ErrnoException) => {
@@ -438,6 +754,10 @@ export async function streamGhaCommand(
     });
   });
 
+  // Drain any partial line buffered by the tracker before we finalise.
+  tracker.flush();
+  tracker.finalize(exitCode);
+
   const completedAt = new Date().toISOString();
   const durationMs =
     new Date(completedAt).getTime() - new Date(startedAt).getTime();
@@ -454,6 +774,11 @@ export async function streamGhaCommand(
     durationMs,
     exitCode,
     ...(errorMessage ? { error: errorMessage } : {}),
+    jobs: tracker.snapshot(),
+    ...(parsed.event ? { event: parsed.event } : {}),
+    ...(workspace.defaultWorkflow
+      ? { workflow: workspace.defaultWorkflow }
+      : {}),
   };
 
   await fs.writeFile(