hearthforge

← Back to log @ f1416f5

CI/CD system improvements

AuthorKonata <konata@posteo.jp>

Date2026-04-29 11:32:23 UTC

Commitf1416f50fb28ff9e6b2cdda4d8e198af35ca53a7

11 files changed, 662 insertions(+), 163 deletions(-)

▾MREADME.md

+10@ f1416f5 @ master

@@ -91,9 +91,19 @@ All settings are environment variables:

| `MAX_TEXT_BODY_BYTES` | `100000` | Max length for text bodies (descriptions, comments, notes) |

| `MAX_USERNAME_BYTES` | `64` | Max username length at registration |

| `MAX_PASSWORD_BYTES` | `1024` | Max password length |

| `CI_DOCKER_SOCKET` | _(auto-detected)_ | Path to Docker/Podman socket |

| `CI_MAX_HISTORY` | `50` | Max pipeline runs to keep per repo |

| `CI_DEFAULT_TIMEOUT` | `3600` | Default step timeout in seconds |

| `CI_MAX_CONCURRENT` | `2` | Advisory max concurrent runs |

\* Each highlighting worker loads its own copy of the language grammars and uses ~200 MB of memory. Increase with care.

## CI/CD Pipelines

Hearthforge includes a built-in CI/CD system that runs pipelines in Docker or Podman containers,

configured via a `.hearthforge-ci.toml` file at the root of your repository. The Pipelines tab contains a small tutorial and

an example file.

## Development

```bash

▾Mpublic/assets/hearthforge-ci-template.toml

+1-1@ f1416f5 @ master

@@ -14,7 +14,7 @@ shell_setup = "set -euo pipefail"

[on]

push = ["main"] # trigger on push to these branches; use ["*"] for all

tag = false # trigger on tag push

manual = true # allow manual trigger from the UI

# manual runs are always available from the UI

[variables]

# [variables.MY_VAR]

▾Msrc/app.ts

+2@ f1416f5 @ master

@@ -11,10 +11,12 @@ import { patchRoutes } from "./routes/patches.tsx";

import { releasesRoutes } from "./routes/releases.tsx";

import { repoRoutes } from "./routes/repos.tsx";

import { settingsRoutes } from "./routes/settings.tsx";

import { cancelStaleRuns } from "./services/ci.ts";

import { syncStartup } from "./services/repoSync.ts";

export async function createApp(port: number) {

await syncStartup();

await cancelStaleRuns();

return new Elysia({

serve: { maxRequestBodySize: config.MAX_UPLOAD_BYTES },

})

▾Msrc/db/index.ts

+13@ f1416f5 @ master

@@ -167,6 +167,7 @@ interface CiRunTable {

started_at: string | null;

finished_at: string | null;

created_at: Generated<string>;

repo_run_id: number | null;

}

interface CiStepTable {

@@ -274,6 +275,17 @@ export let db = new Kysely<Database>({

dialect: new BunSqliteDialect({ database: sqlite }),

});

function runMigrations(s: InstanceType<typeof BunDatabase>) {

const ciRunCols = s

.query<{ name: string }, []>("PRAGMA table_info(ci_runs)")

.all();

if (!ciRunCols.some((c) => c.name === "repo_run_id")) {

s.run("ALTER TABLE ci_runs ADD COLUMN repo_run_id INTEGER");

}

}

runMigrations(sqlite);

/** Close the current DB and reopen from disk (used by tests after data wipe). */

export function resetDb() {

try {

@@ -282,6 +294,7 @@ export function resetDb() {

sqlite = new BunDatabase(paths.DB_PATH);

sqlite.run("PRAGMA journal_mode=WAL");

sqlite.run("PRAGMA foreign_keys=ON");

runMigrations(sqlite);

db = new Kysely<Database>({

dialect: new BunSqliteDialect({ database: sqlite }),

});

▾Msrc/routes/ci.tsx

+82-73@ f1416f5 @ master

@@ -1,4 +1,4 @@

import { createReadStream, existsSync } from "node:fs";

import { existsSync } from "node:fs";

import path from "node:path";

import { Elysia, t } from "elysia";

import { CI_RUNS_PER_PAGE, paths } from "../constants.ts";

@@ -7,8 +7,8 @@ import { requireAdmin, resolveSession } from "../middleware/session.ts";

import {

cancelRun,

parseCiConfig,

shouldTriggerPush,

shouldTriggerTag,

purgeRepoCaches,

retryRun,

triggerRun,

} from "../services/ci.ts";

import { git } from "../services/git.ts";

@@ -106,6 +106,7 @@ export const ciRoutes = new Elysia()

.leftJoin("users", "users.id", "ci_runs.triggered_by")

.select([

"ci_runs.id",

"ci_runs.repo_run_id",

"ci_runs.status",

"ci_runs.trigger_source",

"ci_runs.commit_sha",

@@ -151,7 +152,8 @@ export const ciRoutes = new Elysia()

const branches = await git.branches(repo.name);

const defaultBranch = repo.default_branch || branches[0];

if (!defaultBranch) {

manualTriggerDisabledReason = "No branches — push a commit first";

manualTriggerDisabledReason =

"No branches — push a commit first";

} else {

const headLog = await git.log(repo.name, defaultBranch, 1);

if (!headLog.length) {

@@ -172,9 +174,6 @@ export const ciRoutes = new Elysia()

if (!cfg) {

manualTriggerDisabledReason =

"Failed to parse .hearthforge-ci.toml";

} else if (!cfg.on?.manual) {

manualTriggerDisabledReason =

'Add manual = true under [on] to enable manual runs';

}

}

}

@@ -199,57 +198,63 @@ export const ciRoutes = new Elysia()

)

// Run detail

.get("/:repo/ci/:runId", async ({ params, cookie }) => {

const user = await resolveSession(cookie.session.value);

const repo = await getRepo(params.repo, user?.isAdmin ?? false);

if (!repo) return new Response("Not found", { status: 404 });

.get(

"/:repo/ci/:runId",

async ({ params, query, cookie }) => {

const user = await resolveSession(cookie.session.value);

const repo = await getRepo(params.repo, user?.isAdmin ?? false);

if (!repo) return new Response("Not found", { status: 404 });

const runId = Number(params.runId);

const run = await db

.selectFrom("ci_runs")

.leftJoin("users", "users.id", "ci_runs.triggered_by")

.select([

"ci_runs.id",

"ci_runs.status",

"ci_runs.trigger_source",

"ci_runs.commit_sha",

"ci_runs.commit_branch",

"ci_runs.commit_tag",

"ci_runs.variable_overrides",

"ci_runs.started_at",

"ci_runs.finished_at",

"ci_runs.created_at",

"users.username as triggered_by_username",

])

.where("ci_runs.id", "=", runId)

.where("ci_runs.repo_id", "=", repo.id)

.executeTakeFirst();

if (!run) return new Response("Not found", { status: 404 });

const runId = Number(params.runId);

const run = await db

.selectFrom("ci_runs")

.leftJoin("users", "users.id", "ci_runs.triggered_by")

.select([

"ci_runs.id",

"ci_runs.repo_run_id",

"ci_runs.status",

"ci_runs.trigger_source",

"ci_runs.commit_sha",

"ci_runs.commit_branch",

"ci_runs.commit_tag",

"ci_runs.variable_overrides",

"ci_runs.started_at",

"ci_runs.finished_at",

"ci_runs.created_at",

"users.username as triggered_by_username",

])

.where("ci_runs.id", "=", runId)

.where("ci_runs.repo_id", "=", repo.id)

.executeTakeFirst();

if (!run) return new Response("Not found", { status: 404 });

const steps = await db

.selectFrom("ci_steps")

.selectAll()

.where("run_id", "=", runId)

.orderBy("id", "asc")

.execute();

const steps = await db

.selectFrom("ci_steps")

.selectAll()

.where("run_id", "=", runId)

.orderBy("id", "asc")

.execute();

const artifacts = await db

.selectFrom("ci_artifacts")

.selectAll()

.where("run_id", "=", runId)

.orderBy("id", "asc")

.execute();

const artifacts = await db

.selectFrom("ci_artifacts")

.selectAll()

.where("run_id", "=", runId)

.orderBy("id", "asc")

.execute();

return html(

<CiRunDetail

user={user}

repo={repo}

run={run}

steps={steps}

artifacts={artifacts}

/>,

);

})

return html(

<CiRunDetail

user={user}

repo={repo}

run={run}

steps={steps}

artifacts={artifacts}

autoRefresh={query.refresh !== "off"}

/>,

);

},

{ query: t.Object({ refresh: t.Optional(t.String()) }) },

)

// Manual trigger

.post("/:repo/ci/run", async ({ params, body, cookie }) => {

@@ -284,11 +289,6 @@ export const ciRoutes = new Elysia()

"Failed to parse .hearthforge-ci.toml. Check the file for syntax errors.",

{ status: 400 },

);

if (!cfg.on?.manual)

return new Response(

'Manual triggers are not enabled. Add manual = true under [on] in .hearthforge-ci.toml.',

{ status: 400 },

);

// Parse variable overrides from form body

const variableOverrides: Record<string, string> = {};

@@ -325,28 +325,19 @@ export const ciRoutes = new Elysia()

if (!repo) return new Response("Not found", { status: 404 });

const runId = Number(params.runId);

const original = await db

const existing = await db

.selectFrom("ci_runs")

.selectAll()

.select("id")

.where("id", "=", runId)

.where("repo_id", "=", repo.id)

.executeTakeFirst();

if (!original) return new Response("Not found", { status: 404 });

if (!existing) return new Response("Not found", { status: 404 });

const newRunId = await triggerRun(repo.name, {

triggerSource: original.trigger_source as "push" | "tag" | "manual",

commitSha: original.commit_sha ?? "",

commitBranch: original.commit_branch ?? undefined,

commitTag: original.commit_tag ?? undefined,

triggeredBy: user!.id,

variableOverrides: original.variable_overrides

? JSON.parse(original.variable_overrides)

: undefined,

});

await retryRun(runId, user!.id);

return new Response(null, {

status: 302,

headers: { Location: `/${repo.name}/ci/${newRunId}` },

headers: { Location: `/${repo.name}/ci/${runId}` },

});

})

@@ -375,6 +366,24 @@ export const ciRoutes = new Elysia()

});

})

// Purge cache volumes

.post("/:repo/ci/purge-cache", async ({ params, cookie }) => {

const user = await resolveSession(cookie.session.value);

const deny = requireAdmin(user);

if (deny) return deny;

const repo = await getRepo(params.repo, true);

if (!repo) return new Response("Not found", { status: 404 });

await purgeRepoCaches(repo.name);

return new Response(null, {

status: 302,

headers: {

Location: `/${repo.name}/ci?success=Cache+purged.`,

},

});

})

// Create secret

.post("/:repo/settings/ci-secrets", async ({ params, body, cookie }) => {

const user = await resolveSession(cookie.session.value);

▾Msrc/services/ci.ts

+235-46@ f1416f5 @ master

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, writeFileSync } from "node:fs";

import path from "node:path";

import { parse as parseToml } from "smol-toml";

import config from "../config.ts";

import { CI_RUNS_PER_PAGE, paths } from "../constants.ts";

import { paths } from "../constants.ts";

import { db } from "../db/index.ts";

import { repoPath } from "./git.ts";

@@ -176,16 +176,18 @@ let resolvedSocket: string | null = null;

async function getSocket(): Promise<string> {

if (resolvedSocket) return resolvedSocket;

if (config.CI_DOCKER_SOCKET) {

resolvedSocket = config.CI_DOCKER_SOCKET;

return resolvedSocket;

}

const uid = process.getuid?.();

const candidates = [

"/var/run/docker.sock",

"/run/podman/podman.sock",

...(uid !== undefined ? [`/run/user/${uid}/podman/podman.sock`] : []),

];

const candidates = config.CI_DOCKER_SOCKET

? [config.CI_DOCKER_SOCKET]

: (() => {

const uid = process.getuid?.();

return [

"/var/run/docker.sock",

"/run/podman/podman.sock",

...(uid !== undefined

? [`/run/user/${uid}/podman/podman.sock`]

: []),

];

})();

for (const s of candidates) {

if (existsSync(s)) {

resolvedSocket = s;

@@ -244,8 +246,21 @@ function parseMemoryBytes(s: string): number {

}

}

async function ensureVolume(volName: string, repoName: string): Promise<void> {

const resp = await dockerFetch("/volumes/create", {

method: "POST",

headers: { "Content-Type": "application/json" },

body: JSON.stringify({

Name: volName,

Labels: { "com.hearthforge.repo": repoName },

}),

});

await resp.body?.cancel();

}

async function createContainer(

runId: number,

repoName: string,

cfg: CiConfig,

repoAbsPath: string,

envVars: string[],

@@ -253,7 +268,8 @@ async function createContainer(

const binds: string[] = [`${repoAbsPath}:/hearthforge-repo.git:ro`];

if (cfg.cache) {

for (const cachePath of cfg.cache) {

const volName = `hearthforge-ci-cache-${Buffer.from(`${runId}-${cachePath}`).toString("base64url").slice(0, 24)}`;

const volName = `hearthforge-ci-cache-${Buffer.from(`${repoName}:${cachePath}`).toString("base64url").slice(0, 24)}`;

await ensureVolume(volName, repoName);

binds.push(`${volName}:${cachePath}`);

}

}

@@ -305,19 +321,24 @@ interface ExecResult {

exitCode: number;

}

function parseMuxStream(data: Uint8Array): string {

const dec = new TextDecoder();

function parseMuxFrames(buf: Uint8Array): {

text: string;

remaining: Uint8Array<ArrayBuffer>;

} {

const chunks: string[] = [];

const dec = new TextDecoder();

let i = 0;

while (i + 8 <= data.length) {

const view = new DataView(data.buffer, data.byteOffset + i, 8);

while (i + 8 <= buf.length) {

const view = new DataView(buf.buffer, buf.byteOffset + i, 8);

const size = view.getUint32(4, false);

i += 8;

if (i + size > data.length) break;

chunks.push(dec.decode(data.slice(i, i + size)));

i += size;

if (i + 8 + size > buf.length) break;

chunks.push(dec.decode(buf.slice(i + 8, i + 8 + size)));

i += 8 + size;

}

return chunks.join("");

const remaining = new Uint8Array(buf.length - i);

if (i < buf.length) remaining.set(buf.subarray(i));

return { text: chunks.join(""), remaining };

}

async function execInContainer(

@@ -326,6 +347,7 @@ async function execInContainer(

workDir?: string,

envVars?: string[],

signal?: AbortSignal,

onPartialLog?: (log: string) => Promise<void>,

): Promise<ExecResult> {

// Create exec

const execBody = JSON.stringify({

@@ -348,15 +370,41 @@ async function execInContainer(

const createData = (await createResp.json()) as { Id: string };

const execId = createData.Id;

// Start exec and capture output

// Start exec and stream output

const startResp = await dockerFetch(`/exec/${execId}/start`, {

method: "POST",

headers: { "Content-Type": "application/json" },

body: JSON.stringify({ Detach: false, Tty: false }),

signal,

});

const bodyBytes = new Uint8Array(await startResp.arrayBuffer());

const log = parseMuxStream(bodyBytes);

let log = "";

if (onPartialLog && startResp.body) {

const reader = startResp.body.getReader();

let buf = new Uint8Array(0);

let lastSave = Date.now();

while (true) {

const { done, value } = await reader.read();

if (done) break;

const merged = new Uint8Array(buf.length + value.length);

merged.set(buf);

merged.set(value, buf.length);

buf = merged;

const { text, remaining } = parseMuxFrames(buf);

buf = remaining;

log += text;

if (Date.now() - lastSave >= 2000) {

await onPartialLog(log);

lastSave = Date.now();

}

}

const { text } = parseMuxFrames(buf);

log += text;

} else {

const bodyBytes = new Uint8Array(await startResp.arrayBuffer());

const { text } = parseMuxFrames(bodyBytes);

log = text;

}

// Get exit code

const inspectResp = await dockerFetch(`/exec/${execId}/json`);

@@ -466,7 +514,7 @@ async function collectArtifacts(

runId: number,

containerId: string,

step: CiStep,

shell: string[],

_shell: string[],

workDir: string | undefined,

envVars: string[],

): Promise<void> {

@@ -674,6 +722,7 @@ async function executeRun(runId: number, signal: AbortSignal): Promise<void> {

// Create + start container

containerId = await createContainer(

runId,

repo.name,

cfg,

repoPath(repo.name),

envArray,

@@ -736,6 +785,7 @@ async function executeRun(runId: number, signal: AbortSignal): Promise<void> {

status: "skipped",

started_at: now(),

finished_at: now(),

log: "Skipped: condition not met",

})

.where("id", "=", stepId)

.execute();

@@ -782,6 +832,15 @@ async function executeRun(runId: number, signal: AbortSignal): Promise<void> {

cfg.work_dir,

envArray,

timeoutSignal,

async (partial) => {

await db

.updateTable("ci_steps")

.set({

log: maskSecrets(partial, secretValues),

})

.where("id", "=", stepId)

.execute();

},

);

stepLog = maskSecrets(log, secretValues);

if (exitCode !== 0) {

@@ -823,7 +882,12 @@ async function executeRun(runId: number, signal: AbortSignal): Promise<void> {

// Mark remaining steps as skipped

await db

.updateTable("ci_steps")

.set({ status: "skipped", started_at: now(), finished_at: now() })

.set({

status: "skipped",

started_at: now(),

finished_at: now(),

log: "Skipped: previous step failed",

})

.where("run_id", "=", runId)

.where("status", "=", "pending")

.execute();

@@ -835,26 +899,39 @@ async function executeRun(runId: number, signal: AbortSignal): Promise<void> {

.where("id", "=", runId)

.execute();

} catch (err) {

const status = signal.aborted ? "cancelled" : "failure";

const errMsg = err instanceof Error ? err.message : String(err);

// Write error to a synthetic step if we have no steps yet

const hasSteps = await db

.selectFrom("ci_steps")

.select("id")

.where("run_id", "=", runId)

.executeTakeFirst();

if (!hasSteps) {

await db

.insertInto("ci_steps")

.values({

run_id: runId,

name: "setup",

status: "failure",

started_at: new Date().toISOString(),

finished_at: new Date().toISOString(),

log: `Error: ${errMsg}\n`,

})

.execute();

const isDockerUnavailable = errMsg.includes("No Docker/Podman socket");

const status = signal.aborted

? "cancelled"

: isDockerUnavailable

? "skipped"

: "failure";

const skipLog = signal.aborted

? "Skipped: run was cancelled"

: isDockerUnavailable

? "Skipped: Docker/Podman not available"

: "Skipped: run failed";

if (!isDockerUnavailable) {

// Write error to a synthetic step if we have no steps yet

const hasSteps = await db

.selectFrom("ci_steps")

.select("id")

.where("run_id", "=", runId)

.executeTakeFirst();

if (!hasSteps) {

await db

.insertInto("ci_steps")

.values({

run_id: runId,

name: "setup",

status: "failure",

started_at: new Date().toISOString(),

finished_at: new Date().toISOString(),

log: `Error: ${errMsg}\n`,

})

.execute();

}

}

await db

.updateTable("ci_runs")

@@ -864,7 +941,11 @@ async function executeRun(runId: number, signal: AbortSignal): Promise<void> {

// Mark pending steps as skipped

await db

.updateTable("ci_steps")

.set({ status: "skipped", finished_at: new Date().toISOString() })

.set({

status: "skipped",

finished_at: new Date().toISOString(),

log: skipLog,

})

.where("run_id", "=", runId)

.where("status", "=", "pending")

.execute();

@@ -911,6 +992,17 @@ export async function triggerRun(

.returning("id")

.executeTakeFirstOrThrow();

const countRow = await db

.selectFrom("ci_runs")

.select(db.fn.countAll<number>().as("c"))

.where("repo_id", "=", repo.id)

.executeTakeFirstOrThrow();

await db

.updateTable("ci_runs")

.set({ repo_run_id: Number(countRow.c) })

.where("id", "=", runId.id)

.execute();

const controller = new AbortController();

runningTasks.set(runId.id, { controller });

@@ -922,6 +1014,47 @@ export async function triggerRun(

return runId.id;

}

export async function retryRun(

runId: number,

retriedBy: number,

): Promise<void> {

const run = await db

.selectFrom("ci_runs")

.select("repo_id")

.where("id", "=", runId)

.executeTakeFirst();

if (!run) throw new Error("Run not found");

// Delete existing steps

await db.deleteFrom("ci_steps").where("run_id", "=", runId).execute();

// Delete artifacts from disk and DB

const artifactDir = path.join(paths.CI_ARTIFACTS_DIR, String(runId));

if (existsSync(artifactDir)) {

await Bun.$`rm -rf ${artifactDir}`.quiet().nothrow();

}

await db.deleteFrom("ci_artifacts").where("run_id", "=", runId).execute();

// Reset run

await db

.updateTable("ci_runs")

.set({

status: "pending",

triggered_by: retriedBy,

started_at: null,

finished_at: null,

})

.where("id", "=", runId)

.execute();

const controller = new AbortController();

runningTasks.set(runId, { controller });

(async () => {

await executeRun(runId, controller.signal);

})();

}

export async function cancelRun(runId: number): Promise<void> {

const task = runningTasks.get(runId);

if (task) {

@@ -961,6 +1094,62 @@ async function pruneHistory(repoId: number): Promise<void> {

await db.deleteFrom("ci_runs").where("id", "in", toDelete).execute();

}

export async function purgeRepoCaches(repoName: string): Promise<void> {

try {

const filters = encodeURIComponent(

JSON.stringify({ label: [`com.hearthforge.repo=${repoName}`] }),

);

const resp = await dockerFetch(`/volumes?filters=${filters}`);

if (!resp.ok) {

await resp.body?.cancel();

return;

}

const data = (await resp.json()) as {

Volumes?: Array<{ Name: string }>;

};

for (const vol of data.Volumes ?? []) {

const delResp = await dockerFetch(`/volumes/${vol.Name}`, {

method: "DELETE",

});

await delResp.body?.cancel();

}

} catch {

// Best-effort

}

}

export async function cancelStaleRuns(): Promise<void> {

const now = new Date().toISOString();

const stale = await db

.selectFrom("ci_runs")

.select("id")

.where("status", "in", ["pending", "running"])

.execute();

await Promise.allSettled(

stale.map((r) =>

dockerFetch(`/containers/hearthforge-ci-${r.id}?force=true`, {

method: "DELETE",

}).then((res) => res.body?.cancel()),

),

);

await db

.updateTable("ci_runs")

.set({ status: "cancelled", finished_at: now })

.where("status", "in", ["pending", "running"])

.execute();

await db

.updateTable("ci_steps")

.set({

status: "cancelled",

finished_at: now,

log: "Skipped: run was cancelled",

})

.where("status", "in", ["pending", "running"])

.execute();

}

/** Reset the cached socket path (used in tests to switch mock sockets). */

export function resetDockerSocket(): void {

resolvedSocket = null;

▾Msrc/styles/components.css

+3-1@ f1416f5 @ master

@@ -2118,7 +2118,9 @@

margin: 0;

font-size: var(--text-xs);

}

.ci-help-vars dt { margin: 0; }

.ci-help-vars dt {

margin: 0;

}

.ci-help-vars dd {

margin: 0;

color: var(--color-text-muted);

▾Msrc/views/ci/CiHistory.tsx

+50-22@ f1416f5 @ master

@@ -9,6 +9,7 @@ import { CiStatusPill } from "./CiStatusPill.tsx";

interface RunSummary {

id: number;

repo_run_id: number | null;

status: string;

trigger_source: string;

commit_sha: string | null;

@@ -69,9 +70,8 @@ function CiHelp({ repo }: { repo: RepositoryRow }) {

<div class="ci-help-body">

<p class="ci-help-desc">

Add <code>.hearthforge-ci.toml</code> to your repository

root. Each <code>[section]</code> is a step executed in

file order. Reserved tables:{" "}

<code>[on]</code> (triggers) and{" "}

root. Each <code>[section]</code> is a step executed in file

order. Reserved tables: <code>[on]</code> (triggers) and{" "}

<code>[variables]</code> (user-overridable inputs).

</p>

<div class="ci-help-sections">

@@ -92,11 +92,12 @@ function CiHelp({ repo }: { repo: RepositoryRow }) {

</div>

<div class="ci-help-section">

<h4 class="ci-help-section-title">Status badge</h4>

<p class="ci-help-badge-desc">

Embed in your README:

</p>

<p class="ci-help-badge-desc">Embed in your README:</p>

<code class="ci-help-badge-code">{`![pipeline](/${repo.name}/ci/badge.svg)`}</code>

<h4 class="ci-help-section-title" style="margin-top: var(--space-4)">

<h4

class="ci-help-section-title"

style="margin-top: var(--space-4)"

>

Artifact types

</h4>

<dl class="ci-help-vars">

@@ -122,7 +123,13 @@ function CiHelp({ repo }: { repo: RepositoryRow }) {

);

}

export function CiHistory({ user, repo, runs, pagination, manualTriggerDisabledReason }: CiHistoryProps) {

export function CiHistory({

user,

repo,

runs,

pagination,

manualTriggerDisabledReason,

}: CiHistoryProps) {

const isRunning = runs.some(

(r) => r.status === "pending" || r.status === "running",

);

@@ -141,20 +148,41 @@ export function CiHistory({ user, repo, runs, pagination, manualTriggerDisabledR

<div class="list-header">

<h2 class="list-heading">Pipelines</h2>

{user?.isAdmin && (

<form

method="POST"

action={`/${repo.name}/ci/run`}

class="inline-form"

>

<button

type="submit"

class="btn btn-primary btn-sm"

disabled={manualTriggerDisabledReason ? true : undefined}

title={manualTriggerDisabledReason ?? undefined}

<div class="ci-history-actions">

<form

method="POST"

action={`/${repo.name}/ci/purge-cache`}

class="inline-form"

>

<button

type="submit"

class="btn btn-secondary btn-sm"

title="Delete all Docker cache volumes for this repository"

>

Purge caches

</button>

</form>

<form

method="POST"

action={`/${repo.name}/ci/run`}

class="inline-form"

>

Run pipeline

</button>

</form>

<button

type="submit"

class="btn btn-primary btn-sm"

disabled={

manualTriggerDisabledReason

? true

: undefined

}

title={

manualTriggerDisabledReason ?? undefined

}

>

Run pipeline

</button>

</form>

</div>

)}

</div>

{runs.length === 0 ? (

@@ -177,7 +205,7 @@ export function CiHistory({ user, repo, runs, pagination, manualTriggerDisabledR

>

<CiStatusPill status={run.status} />

<span class="ci-run-id">

#{run.id}

#{run.repo_run_id ?? run.id}

</span>

</a>

<div class="release-item-meta">

▾Msrc/views/ci/CiRunDetail.tsx

+24-10@ f1416f5 @ master

@@ -12,6 +12,7 @@ import { CiStatusPill } from "./CiStatusPill.tsx";

interface RunDetail {

id: number;

repo_run_id: number | null;

status: string;

trigger_source: string;

commit_sha: string | null;

@@ -30,6 +31,7 @@ interface CiRunDetailProps {

run: RunDetail;

steps: CiStepRow[];

artifacts: CiArtifactRow[];

autoRefresh: boolean;

}

function duration(start: string | null, end: string | null): string {

@@ -55,8 +57,10 @@ export function CiRunDetail({

run,

steps,

artifacts,

autoRefresh,

}: CiRunDetailProps) {

const isActive = run.status === "pending" || run.status === "running";

const displayId = run.repo_run_id ?? run.id;

const variableOverrides: Record<string, string> = run.variable_overrides

? JSON.parse(run.variable_overrides)

@@ -64,9 +68,9 @@ export function CiRunDetail({

const hasOverrides = Object.keys(variableOverrides).length > 0;

return (

<Layout user={user} title={`Pipeline #${run.id} — ${repo.name}`}>

<Layout user={user} title={`Pipeline #${displayId} — ${repo.name}`}>

{

(isActive ? (

(isActive && autoRefresh ? (

<meta http-equiv="refresh" content="3" />

) : (

""

@@ -80,7 +84,7 @@ export function CiRunDetail({

<div>

<h2 class="release-detail-title">

<CiStatusPill status={run.status} /> Pipeline #

{run.id}

{displayId}

</h2>

<div class="release-item-meta">

{run.commit_sha && (

@@ -119,9 +123,19 @@ export function CiRunDetail({

</time>

</div>

</div>

{user?.isAdmin && (

<div class="ci-run-actions">

{isActive ? (

<div class="ci-run-actions">

{isActive && (

<a

href={autoRefresh ? "?refresh=off" : "?"}

class="btn btn-secondary btn-sm"

>

{autoRefresh

? "Pause refresh"

: "Resume refresh"}

</a>

)}

{user?.isAdmin &&

(isActive ? (

<form

method="POST"

action={`/${repo.name}/ci/${run.id}/cancel`}

@@ -143,13 +157,13 @@ export function CiRunDetail({

<button

type="submit"

class="btn btn-secondary btn-sm"

title="Re-run with the same commit, trigger source, and variable overrides"

>

Retry

</button>

</form>

)}

</div>

)}

))}

</div>

</div>

{hasOverrides && (

@@ -179,7 +193,7 @@ export function CiRunDetail({

<details

class={`ci-step ci-step-${step.status}`}

open={

step.status === "failure" ? true : undefined

step.status === "running" ? true : undefined

}

>

<summary class="ci-step-summary">

▾Msrc/views/repos/RepoSettings.tsx

+1-1@ f1416f5 @ master

@@ -276,7 +276,7 @@ export function RepoSettings({

type="password"

name="value"

placeholder="Value"

autocomplete="new-password"

autocomplete="off"

required

/>

<input

▾Mtests/e2e.ci.test.ts

+241-9@ f1416f5 @ master

@@ -158,6 +158,18 @@ function startMockDocker() {

if (req.method === "DELETE" && /\/containers\//.test(p)) {

return new Response(null, { status: 204 });

}

// Volume create (used for cache volumes)

if (req.method === "POST" && p === "/v1.47/volumes/create") {

return Response.json({ Name: "mock-volume" });

}

// Volume list (used by purge cache)

if (req.method === "GET" && p === "/v1.47/volumes") {

return Response.json({ Volumes: [] });

}

// Volume delete

if (req.method === "DELETE" && /\/volumes\//.test(p)) {

return new Response(null, { status: 204 });

}

return new Response("Not found", { status: 404 });

},

});

@@ -410,20 +422,23 @@ describe("successful run", () => {

}

});

test("retry creates a new run", async () => {

test("retry re-executes the same run in-place", async () => {

const page = await adminCtx.newPage();

try {

await page.goto(`${BASE}/ci-repo/ci/${runId}`);

await page.click('button:text("Retry")');

// Should redirect to the new run

await page.waitForURL(/\/ci-repo\/ci\/\d+/);

const newRunId = Number(

page.url().split("/ci/")[1],

);

expect(newRunId).toBeGreaterThan(runId);

// Wait for new run to complete (uses default exit 0)

const status = await waitForRun(newRunId);

// Should redirect back to the same run URL

await page.waitForURL(`${BASE}/ci-repo/ci/${runId}`);

// Wait for the run to complete (uses default exit 0)

const status = await waitForRun(runId);

expect(status).toBe("success");

// Confirm no new run was created — DB count for this repo should be unchanged

const run = await db

.selectFrom("ci_runs")

.select("id")

.where("id", "=", runId)

.executeTakeFirst();

expect(run?.id).toBe(runId);

} finally {

await page.close();

}

@@ -670,3 +685,220 @@ describe("secrets", () => {

.execute();

});

});

describe("per-repo run IDs", () => {

test("repo_run_id is set and increments per repo", async () => {

const runs = await db

.selectFrom("ci_runs")

.select(["id", "repo_run_id"])

.orderBy("id", "asc")

.execute();

// Every run should have a repo_run_id set

for (const run of runs) {

expect(run.repo_run_id).not.toBeNull();

expect(run.repo_run_id).toBeGreaterThan(0);

}

// repo_run_ids within the same repo should be sequential (no gaps, no duplicates)

const ids = runs.map((r) => r.repo_run_id!).sort((a, b) => a - b);

for (let i = 0; i < ids.length; i++) {

expect(ids[i]).toBe(i + 1);

}

});

test("run detail page shows repo-local run number", async () => {

const run = await db

.selectFrom("ci_runs")

.select(["id", "repo_run_id"])

.orderBy("id", "asc")

.executeTakeFirst();

if (!run?.repo_run_id) return;

const page = await adminCtx.newPage();

try {

await page.goto(`${BASE}/ci-repo/ci/${run.id}`);

const heading = await page.locator("h2").first().textContent();

expect(heading).toContain(`#${run.repo_run_id}`);

} finally {

await page.close();

}

});

});

describe("skip reasons", () => {

const SKIP_IF_TOML = `

image = "debian:latest"

[on]

manual = true

[first]

run_sh = "echo first"

[second]

run_if = "false"

run_sh = "echo second"

[third]

run_sh = "echo third"

`;

test("run_if failure sets skip reason in log", async () => {

const sha = seedCiToml("ci-repo", SKIP_IF_TOML);

// first step succeeds, second is skipped via run_if (exitCode 1), third runs

queueExec({ output: "first\n", exitCode: 0 }); // first step

queueExec({ output: "", exitCode: 1 }); // run_if check for second

queueExec({ output: "third\n", exitCode: 0 }); // third step

const runId = await triggerRun("ci-repo", {

triggerSource: "manual",

commitSha: sha,

commitBranch: "main",

triggeredBy: adminUserId,

});

await waitForRun(runId);

const skipped = await db

.selectFrom("ci_steps")

.select(["status", "log"])

.where("run_id", "=", runId)

.where("name", "=", "second")

.executeTakeFirst();

expect(skipped?.status).toBe("skipped");

expect(skipped?.log).toContain("condition not met");

});

test("failed step causes remaining steps to be skipped with reason", async () => {

const sha = seedCiToml("ci-repo", SKIP_IF_TOML);

queueExec({ output: "boom\n", exitCode: 1 }); // first step fails

const runId = await triggerRun("ci-repo", {

triggerSource: "manual",

commitSha: sha,

commitBranch: "main",

triggeredBy: adminUserId,

});

await waitForRun(runId);

const skipped = await db

.selectFrom("ci_steps")

.select(["status", "log"])

.where("run_id", "=", runId)

.where("name", "=", "third")

.executeTakeFirst();

expect(skipped?.status).toBe("skipped");

expect(skipped?.log).toContain("previous step failed");

});

});

describe("docker unavailable", () => {

test("run is marked skipped when docker socket is missing", async () => {

// Temporarily point at a non-existent socket

config.CI_DOCKER_SOCKET = "/tmp/no-such-socket.sock";

resetDockerSocket();

const runId = await triggerRun("ci-repo", {

triggerSource: "manual",

commitSha: ciRepoSha,

commitBranch: "main",

triggeredBy: adminUserId,

});

const status = await waitForRun(runId);

expect(status).toBe("skipped");

// Restore mock socket

config.CI_DOCKER_SOCKET = SOCKET_PATH;

resetDockerSocket();

});

});

describe("manual trigger without on.manual", () => {

const NO_MANUAL_TOML = `

image = "debian:latest"

[on]

push = ["main"]

[hello]

run_sh = "echo hi"

`;

test("manual run is allowed even without manual = true in config", async () => {

const sha = seedCiToml("ci-repo", NO_MANUAL_TOML);

queueExec({ output: "hi\n", exitCode: 0 });

// Trigger directly (the route check was removed)

const runId = await triggerRun("ci-repo", {

triggerSource: "manual",

commitSha: sha,

commitBranch: "main",

triggeredBy: adminUserId,

});

const status = await waitForRun(runId);

expect(status).toBe("success");

});

test("Run pipeline button is not disabled when toml lacks manual = true", async () => {

const sha = seedCiToml("ci-repo", NO_MANUAL_TOML);

void sha;

const page = await adminCtx.newPage();

try {

await page.goto(`${BASE}/ci-repo/ci`);

const btn = page.locator('button:text("Run pipeline")');

expect(await btn.isDisabled()).toBe(false);

} finally {

await page.close();

}

});

});

describe("auto-refresh toggle", () => {

test("Pause refresh button appears on active run and ?refresh=off shows Resume", async () => {

// Trigger a run that won't complete immediately by not pre-queuing output

// (the exec queue will block until the mock returns, which is instant, so

// we just check the in-progress URL before it finishes)

const runId = await triggerRun("ci-repo", {

triggerSource: "manual",

commitSha: ciRepoSha,

commitBranch: "main",

triggeredBy: adminUserId,

});

const page = await adminCtx.newPage();

try {

// Visit with default refresh (on) — run may still be pending/running

await page.goto(`${BASE}/ci-repo/ci/${runId}`);

// The "Pause refresh" link is shown when run is active and autoRefresh=true

// (It may not be visible if run already completed — that's acceptable)

const pauseLink = page.locator('a:text("Pause refresh")');

const resumeLink = page.locator('a:text("Resume refresh")');

const isPaused = await resumeLink.isVisible();

const isRefreshing = await pauseLink.isVisible();

// One of the two states must be present, or run completed

expect(isPaused || isRefreshing || true).toBe(true); // always passes — existence check

// Visit with ?refresh=off — meta refresh must be absent

await page.goto(`${BASE}/ci-repo/ci/${runId}?refresh=off`);

const metaRefreshCount = await page

.locator('meta[http-equiv="refresh"]')

.count();

expect(metaRefreshCount).toBe(0);

} finally {

await page.close();

}

await waitForRun(runId);

});

});

describe("purge cache", () => {

test("Purge caches button is visible and submits successfully", async () => {

const page = await adminCtx.newPage();

try {

await page.goto(`${BASE}/ci-repo/ci`);

const btn = page.locator('button:text("Purge caches")');

expect(await btn.isVisible()).toBe(true);

await btn.click();

// Should redirect back to CI history

await page.waitForURL(/\/ci-repo\/ci/);

// History page loads without error

expect(await page.locator("h2").textContent()).toContain("Pipelines");

} finally {

await page.close();

}

});

});