create-interview-cockpit 0.17.3 → 0.19.0

package/template/client/src/githubActionsLab.ts

@@ -0,0 +1,294 @@
+import type { GithubActionsLabWorkspace } from "./types";
+
+// ─── Default Lab Template ────────────────────────────────────────────────
+//
+// A self-contained playground that mirrors how GitHub Actions actually works:
+//   - one workflow under .github/workflows/ci.yml
+//   - a local composite action under .github/actions/say-hello/action.yml
+//     (referenced via `uses: ./.github/actions/say-hello`)
+//   - a public marketplace action via `uses: actions/checkout@v4`
+//   - a tiny script the workflow runs to prove the workspace was checked out
+//
+// Run it with the lab's Run button. `act` will pull `actions/checkout`
+// from GitHub the first time, then execute everything inside Docker locally.
+
+const DEFAULT_FILES: Record<string, string> = {
+  "README.md": `# GitHub Actions Local Playground
+
+This lab runs your workflows on your own machine using [\`act\`](https://github.com/nektos/act),
+the same tool GitHub recommends for testing Actions locally.
+
+## First-time setup
+
+You need two things on your host:
+
+1. **Docker** — already required by other labs.
+2. **act** — install once:
+   - macOS: \`brew install act\`
+   - Linux: \`curl https://raw.githubusercontent.com/nektos/act/master/install.sh | sudo bash\`
+
+The first run will pull a runner image (~500 MB). Subsequent runs are fast.
+
+## How to use this lab
+
+- The left tree shows the workspace, exactly like a Git checkout.
+- Workflows live under \`.github/workflows/\` — \`act\` discovers them automatically.
+- Local actions live under \`.github/actions/<name>/action.yml\` — reference them with \`uses: ./.github/actions/<name>\`.
+- Public actions like \`actions/checkout@v4\` are pulled from GitHub on first use.
+- Pick an event (push, pull_request, workflow_dispatch), pick a workflow, and click **Run**.
+- The right pane streams the live log, just like the Actions tab on GitHub.
+
+## What this template demonstrates
+
+- A **multi-job workflow** with \`needs:\` for ordering
+- A **local composite action** invoked via \`uses: ./.github/actions/...\`
+- A **marketplace action** invoked via \`uses: actions/checkout@v4\`
+- **Workflow inputs** with \`workflow_dispatch\`
+- **Job outputs** + **\${{ steps.x.outputs.y }}** expressions
+- A **matrix** strategy across Node versions
+
+## Useful console commands
+
+The Console tab on the right also supports:
+
+  act -l                            # list jobs in all workflows
+  act -W .github/workflows/ci.yml -l
+  act push                          # simulate a push event
+  act pull_request                  # simulate a pull_request event
+  act workflow_dispatch -j greet    # run a single job
+  act -n                            # dry run (no Docker needed)
+
+\`act\` flags are sandboxed; only flags listed above are allowed.
+`,
+
+  ".github/workflows/ci.yml": `name: CI
+
+# Trigger on push, PRs, and a manual button (workflow_dispatch).
+# Inputs let you test how reusable parameters flow through the run.
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      greeting:
+        description: "Greeting to print"
+        required: false
+        default: "Hello from local act!"
+
+jobs:
+  # Job 1 — uses a local composite action you can edit in this lab.
+  greet:
+    runs-on: ubuntu-latest
+    outputs:
+      stamp: \${{ steps.hello.outputs.stamp }}
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+
+      - name: Say hello (local composite action)
+        id: hello
+        uses: ./.github/actions/say-hello
+        with:
+          name: \${{ github.event.inputs.greeting || 'world' }}
+
+      - name: Show output from the composite action
+        run: echo "Composite action returned stamp=\${{ steps.hello.outputs.stamp }}"
+
+  # Job 2 — depends on greet, runs a matrix of Node versions.
+  build:
+    needs: greet
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version: [18, 20]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Show inherited output
+        run: echo "Previous job said \${{ needs.greet.outputs.stamp }}"
+
+      - name: Print Node version inside the runner
+        run: node --version
+
+      - name: Run the workspace script
+        run: node scripts/build.js \${{ matrix.node-version }}
+`,
+
+  ".github/actions/say-hello/action.yml": `# This is a LOCAL composite action.
+# The workflow references it with: uses: ./.github/actions/say-hello
+#
+# Composite actions are how you package reusable step sequences without
+# publishing to the Marketplace. They take inputs, run steps, and return outputs.
+
+name: "Say Hello"
+description: "Prints a greeting and emits a stamp output."
+
+inputs:
+  name:
+    description: "Who to greet"
+    required: true
+    default: "world"
+
+outputs:
+  stamp:
+    description: "ISO timestamp of when the action ran"
+    value: \${{ steps.gen.outputs.stamp }}
+
+runs:
+  using: "composite"
+  steps:
+    - name: Greet
+      shell: bash
+      run: echo "Hello, \${{ inputs.name }}!"
+
+    - name: Generate output
+      id: gen
+      shell: bash
+      run: echo "stamp=$(date -u +%FT%TZ)" >> "$GITHUB_OUTPUT"
+`,
+
+  "scripts/build.js": `// Tiny script the workflow runs to prove your repo files are checked out
+// inside the runner container.
+const nodeMajor = process.argv[2] || "unknown";
+console.log(\`[build] running on Node \${nodeMajor}\`);
+console.log(\`[build] cwd = \${process.cwd()}\`);
+console.log("[build] workspace files visible to the job:");
+require("fs").readdirSync(".").forEach((f) => console.log("  -", f));
+`,
+
+  ".actrc": `# Default flags act will pick up from the workspace.
+# Pinning the runner image keeps installs reproducible across machines.
+-P ubuntu-latest=catthehacker/ubuntu:act-latest
+--container-architecture linux/amd64
+`,
+};
+
+export const DEFAULT_GHA_LAB: GithubActionsLabWorkspace = {
+  version: 1,
+  label: "GitHub Actions Playground",
+  activeFile: ".github/workflows/ci.yml",
+  defaultEvent: "push",
+  defaultWorkflow: ".github/workflows/ci.yml",
+  files: DEFAULT_FILES,
+};
+
+// ─── Helpers (mirror infraLab.ts API surface) ────────────────────────────
+
+export function cloneGhaLabWorkspace(
+  workspace?: GithubActionsLabWorkspace | null,
+): GithubActionsLabWorkspace {
+  const source = workspace ?? DEFAULT_GHA_LAB;
+  const sourceFiles =
+    source.files && Object.keys(source.files).length > 0
+      ? { ...source.files }
+      : { ...DEFAULT_FILES };
+  const activeFile = sourceFiles[source.activeFile]
+    ? source.activeFile
+    : (Object.keys(sourceFiles)[0] ?? ".github/workflows/ci.yml");
+
+  return {
+    version: 1,
+    label: source.label || DEFAULT_GHA_LAB.label,
+    activeFile,
+    defaultEvent: source.defaultEvent || "push",
+    defaultWorkflow:
+      source.defaultWorkflow && sourceFiles[source.defaultWorkflow]
+        ? source.defaultWorkflow
+        : Object.keys(sourceFiles).find((f) =>
+            f.startsWith(".github/workflows/"),
+          ) || ".github/workflows/ci.yml",
+    files: sourceFiles,
+    // Preserve optional UX flags so they round-trip through save/load.
+    ...(source.includeRunHistoryInContext
+      ? { includeRunHistoryInContext: true }
+      : {}),
+  };
+}
+
+export function getGhaLabFileOrder(
+  workspace: GithubActionsLabWorkspace,
+): string[] {
+  const all = Object.keys(workspace.files);
+  // Surface workflows first, then composite actions, then scripts, then rest.
+  const workflows = all
+    .filter((p) => p.startsWith(".github/workflows/"))
+    .sort();
+  const actions = all
+    .filter((p) => p.startsWith(".github/actions/") && !workflows.includes(p))
+    .sort();
+  const scripts = all
+    .filter(
+      (p) =>
+        (p.startsWith("scripts/") || p === "package.json") &&
+        !workflows.includes(p) &&
+        !actions.includes(p),
+    )
+    .sort();
+  const rest = all
+    .filter(
+      (p) =>
+        !workflows.includes(p) && !actions.includes(p) && !scripts.includes(p),
+    )
+    .sort((a, b) => {
+      if (a === "README.md") return -1;
+      if (b === "README.md") return 1;
+      return a.localeCompare(b);
+    });
+  return [...rest, ...workflows, ...actions, ...scripts];
+}
+
+export function listWorkflowPaths(
+  workspace: GithubActionsLabWorkspace,
+): string[] {
+  return Object.keys(workspace.files)
+    .filter((p) => /^\.github\/workflows\/.+\.(ya?ml)$/i.test(p))
+    .sort();
+}
+
+export function serializeGhaLabWorkspace(
+  workspace: GithubActionsLabWorkspace,
+): string {
+  return JSON.stringify(cloneGhaLabWorkspace(workspace), null, 2);
+}
+
+export function parseGhaLabWorkspace(
+  raw: string,
+): GithubActionsLabWorkspace | null {
+  try {
+    const parsed = JSON.parse(raw) as Partial<GithubActionsLabWorkspace> & {
+      files?: Record<string, unknown>;
+    };
+    if (!parsed || typeof parsed !== "object") return null;
+    if (!parsed.files || typeof parsed.files !== "object") return null;
+    const files = Object.fromEntries(
+      Object.entries(parsed.files).filter(
+        (entry): entry is [string, string] => typeof entry[1] === "string",
+      ),
+    );
+    if (Object.keys(files).length === 0) return null;
+    return cloneGhaLabWorkspace({
+      version: 1,
+      label:
+        typeof parsed.label === "string" && parsed.label.trim()
+          ? parsed.label.trim()
+          : DEFAULT_GHA_LAB.label,
+      activeFile:
+        typeof parsed.activeFile === "string"
+          ? parsed.activeFile
+          : DEFAULT_GHA_LAB.activeFile,
+      defaultEvent:
+        typeof parsed.defaultEvent === "string" ? parsed.defaultEvent : "push",
+      defaultWorkflow:
+        typeof parsed.defaultWorkflow === "string"
+          ? parsed.defaultWorkflow
+          : DEFAULT_GHA_LAB.defaultWorkflow,
+      files,
+      ...(parsed.includeRunHistoryInContext === true
+        ? { includeRunHistoryInContext: true }
+        : {}),
+    });
+  } catch {
+    return null;
+  }
+}