create-interview-cockpit 0.18.0 → 0.20.0

package/template/client/src/store.ts

@@ -128,6 +128,10 @@ interface Store {
   renameWorkspace: (id: string, name: string) => Promise<void>;
   patchWorkspace: (id: string, data: object) => Promise<void>;
   syncWorkspace: (id: string) => Promise<import("./api").SyncWorkspaceResult>;
+  syncTopic: (
+    workspaceId: string,
+    topicId: string,
+  ) => Promise<import("./api").SyncWorkspaceResult>;
   linkDriveFolder: (
     workspaceId: string,
     url: string,
@@ -144,6 +148,11 @@ interface Store {
     id: string,
     targetFolderId?: string,
   ) => Promise<import("./api").ExportWorkspaceResult>;
+  exportTopic: (
+    workspaceId: string,
+    topicId: string,
+    targetFolderId?: string,
+  ) => Promise<import("./api").ExportWorkspaceResult>;
   fetchDriveSubfolders: (id: string) => Promise<import("./api").DriveFolder[]>;
   createDriveSubfolder: (
     id: string,
@@ -494,6 +503,40 @@ export const useStore = create<Store>((set, get) => ({
     return result;
   },
 
+  syncTopic: async (workspaceId, topicId) => {
+    const result = await api.syncTopicApi(workspaceId, topicId);
+    if ("needsAuth" in result && result.needsAuth) {
+      return result;
+    }
+    if (workspaceId === get().activeWorkspaceId) {
+      const [topics, questions] = await Promise.all([
+        api.fetchTopics(),
+        api.fetchQuestions(topicId),
+      ]);
+      set((s) => {
+        const selectedStillExists = questions.some(
+          (q) => q.id === s.selectedQuestionId,
+        );
+        const selectedWasInTopic = s.currentQuestion?.topicId === topicId;
+        return {
+          topics,
+          questionsByTopic: { ...s.questionsByTopic, [topicId]: questions },
+          selectedQuestionId:
+            selectedWasInTopic && !selectedStillExists
+              ? null
+              : s.selectedQuestionId,
+          currentQuestion:
+            selectedWasInTopic && !selectedStillExists
+              ? null
+              : s.currentQuestion,
+        };
+      });
+    }
+    const registry = await api.fetchWorkspaces();
+    set({ workspaces: registry.workspaces });
+    return result;
+  },
+
   linkDriveFolder: async (workspaceId, url) => {
     const { registry, folders } = await api.linkDriveFolder(workspaceId, url);
     set({ workspaces: registry.workspaces, driveRootFolders: folders });
@@ -556,6 +599,10 @@ export const useStore = create<Store>((set, get) => ({
     return api.exportWorkspaceToDrive(id, targetFolderId);
   },
 
+  exportTopic: async (workspaceId, topicId, targetFolderId) => {
+    return api.exportTopicToDrive(workspaceId, topicId, targetFolderId);
+  },
+
   fetchDriveSubfolders: async (id) => {
     return api.fetchDriveSubfolders(id);
   },

package/template/client/src/types.ts

@@ -58,6 +58,12 @@ export interface GithubActionsLabWorkspace {
   defaultEvent?: string;
   /** Optional default workflow file path under .github/workflows. */
   defaultWorkflow?: string;
+  /**
+   * When true, the most recent act runs for this lab are embedded into the
+   * saved snapshot so the chat LLM can reason about real execution results
+   * (job statuses, durations, exit codes) instead of just the YAML.
+   */
+  includeRunHistoryInContext?: boolean;
 }
 
 export interface WorkspaceMeta {

package/template/client/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/app.tsx","./src/api.ts","./src/browsersecuritytemplates.ts","./src/enterpriselocallab.ts","./src/githubactionslab.ts","./src/infralab.ts","./src/main.tsx","./src/reactlab.ts","./src/store.ts","./src/types.ts","./src/vite-env.d.ts","./src/components/aisettingsmodal.tsx","./src/components/annotationdialog.tsx","./src/components/browsersecuritylabmodal.tsx","./src/components/canvaslabmodal.tsx","./src/components/chatmessage.tsx","./src/components/chatview.tsx","./src/components/codecontextpanel.tsx","./src/components/codelineannotationpopup.tsx","./src/components/coderunnermodal.tsx","./src/components/deploymentlabmodal.tsx","./src/components/docrefmodal.tsx","./src/components/fileattachments.tsx","./src/components/filepickermodal.tsx","./src/components/fileviewermodal.tsx","./src/components/githubactionslabmodal.tsx","./src/components/infralabmodal.tsx","./src/components/labspanel.tsx","./src/components/linkedconvospicker.tsx","./src/components/markdownrenderer.tsx","./src/components/mermaiddiagram.tsx","./src/components/notesmodal.tsx","./src/components/plotembed.tsx","./src/components/sidebar.tsx","./src/components/textannotator.tsx","./src/components/vizcraftembed.tsx","./src/components/workspaceswitcher.tsx"],"version":"5.9.3"}
+{"root":["./src/app.tsx","./src/api.ts","./src/browsersecuritytemplates.ts","./src/enterpriselocallab.ts","./src/githubactionslab.ts","./src/infralab.ts","./src/main.tsx","./src/reactlab.ts","./src/store.ts","./src/types.ts","./src/vite-env.d.ts","./src/components/aisettingsmodal.tsx","./src/components/annotationdialog.tsx","./src/components/browsersecuritylabmodal.tsx","./src/components/canvaslabmodal.tsx","./src/components/chatmessage.tsx","./src/components/chatview.tsx","./src/components/codecontextpanel.tsx","./src/components/codelineannotationpopup.tsx","./src/components/coderunnermodal.tsx","./src/components/deploymentlabmodal.tsx","./src/components/docrefmodal.tsx","./src/components/fileattachments.tsx","./src/components/filepickermodal.tsx","./src/components/fileviewermodal.tsx","./src/components/ghahistorypanel.tsx","./src/components/ghajobspanel.tsx","./src/components/githubactionslabmodal.tsx","./src/components/infralabmodal.tsx","./src/components/labspanel.tsx","./src/components/linkedconvospicker.tsx","./src/components/markdownrenderer.tsx","./src/components/mermaiddiagram.tsx","./src/components/notesmodal.tsx","./src/components/plotembed.tsx","./src/components/sidebar.tsx","./src/components/textannotator.tsx","./src/components/vizcraftembed.tsx","./src/components/workspaceswitcher.tsx"],"version":"5.9.3"}

package/template/cockpit.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.17.2"
+  "version": "0.18.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 };
 
@@ -137,7 +180,8 @@ function parseWorkspace(input: unknown): GithubActionsLabWorkspace {
         ? candidate.label.trim()
         : "GitHub Actions Lab",
     activeFile:
-      typeof candidate.activeFile === "string" && files[candidate.activeFile]
+      typeof candidate.activeFile === "string" &&
+      Object.prototype.hasOwnProperty.call(files, candidate.activeFile)
         ? candidate.activeFile
         : fileNames[0],
     defaultEvent:
@@ -362,6 +406,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 +697,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 +722,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 +755,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 +775,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(