mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-16 11:48:15 +01:00
## Thinking Path > - Paperclip is the open source app people use to manage AI agents for work > - The Runner is the part that executes agent work. `master` publishes it alone as the image `ghcr.io/paperclipai/paperclip-runner`, once for each set of its inputs > - The application image will copy that Runner instead of making its own. `scripts/runner-image-resolve.mjs` tells a build whether the Runner of its inputs is published > - On a `master` push, the commit's own run of `runner-image.yml` is often still publishing when the application build asks. The resolver answers once, so that build is told `absent` for an image that exists some minutes later > - The resolver also cannot say that a tree is not safe to give a published Runner to. A `Dockerfile` that does not check the Runner it receives builds with any Runner > - This pull request adds an opt-in wait for the commit's own publication run, and an `unsupported` answer for a `Dockerfile` that cannot check its Runner > - The benefit is that the next pull request can let `docker.yml` copy the published Runner without a blind timeout and without a label that is not true ## Linked Issues or Issue Description Refs #21204, #21229, #21230 (the Runner image), #21306 (the resolver), #21307 (the report-only job), and #21331, #21332, #21333 (the application image takes its Runner from `runner-artifacts`). No issue exists for this change. **Problem or motivation** A `master` push starts `runner-image.yml` and `docker.yml` at the same time. Publication takes about 30 minutes from the push, and several of those minutes are runner queue time. An application build that asks the resolver at once gets `absent` for every commit that changes the Runner's inputs, and for commits that follow one closely. A fixed poll of the tag has the opposite fault: when no image will ever come (the lockfile is behind, or the run failed), every build waits the full timeout. **Proposed solution** `resolve --wait` waits for a run, not for a time. It finds the runs of `runner-image.yml` for the push of the commit to `master`, and it looks up the image again when they end. No caller uses the flag in this pull request, so no workflow changes behavior. **Alternatives considered** - Poll the tag until a timeout. Every build with no image to come waits the full timeout. - Call `runner-image.yml` from `docker.yml` as a reusable workflow. Publication would then share the one concurrency slot of `docker.yml`. - Wait until the run completes and only then look. The run goes on after publication (it writes the build cache), so the wait would last longer than needed. The command looks up the image while a run is in progress. - Verify the attestation in the resolver. The workflow that uses the answer does it, in a step of its own, in the next pull request. **Roadmap alignment** This is build infrastructure. It adds no product feature and does not overlap an item in `ROADMAP.md`. This pull request is built on #21333. Merge in this order: 1. #21331, #21332, #21333: the application image takes its Runner from the `runner-artifacts` stage, checks the inputs digest a build names, and stops early on a stale lockfile. 2. This pull request: the wait and the `unsupported` answer of the resolver. 3. `runner/app-image-consume-docker`: `docker.yml` copies the published Runner, behind a repository variable. The same change for the preview cloud image build in `release.yml` is deferred. It has no pull request yet. ## What Changed - `scripts/runner-image-resolve.mjs` - `resolve --dir <directory> --wait`. When the first answer is `absent` or `incomplete`, the command lists the runs of `runner-image.yml` for the commit (Actions API, `GITHUB_SHA`, `GITHUB_TOKEN`) and looks again when they end. - Only a run of the `push` event on `master` in this repository counts. A pull-request, scheduled or manual run of the same commit is never waited for. The request filters by event and branch, and the script checks each run again. - A run that fails, is cancelled or publishes nothing ends the wait when it ends. With several runs for one commit, the command waits for all of them. - While a run is in progress, the command looks up the image every 30 seconds, so the wait ends at publication. - A run that is not listed yet is looked for during 2 minutes. - The limit is 40 minutes from the push: `RUNNER_IMAGE_WAIT_MINUTES`, the one constant. The push time is the creation time of the oldest run of the commit, so a build that starts late waits less. - Three failed API requests in a row end the wait. No token or no full commit SHA means no wait. - After every ending the command looks up the image one last time. No ending is an error. Without an image the answer is `inline`, and the command prints a notice with the reason. - `inputs` reads the `Dockerfile` first. Without a line `ARG PAPERCLIP_RUNNER_EXPECT_INPUTS_DIGEST` it runs no build, and `resolve` answers `inline` with the reason `unsupported`. - `resolve` reports `build_args`: the value of that argument for a `published` answer. - The wait and the list of runs take the clock, the sleep and `fetch` as arguments, so the tests use no network and do not sleep. - `server/src/__tests__/runner-image-resolve.test.ts`: every outcome of the wait and the answer that follows it, the run filter, the limit measured from the push, the API failures, and the command line. - `doc/runner-image-contract.md`: a "Waiting for a publication" section, `build_args`, and the `unsupported` answer. ## Verification macOS (Node 26.12.0) and Linux (`node:24.22.3-bookworm`, linux/arm64, with `jq` and `zstd` added), on this branch on top of #21333: - `pnpm exec vitest run` on `runner-image-resolve`, `docker-runner-workflows`, `runner-image-workflow`, `docker-build-stamp`, `container-init-reaping`, `cloud-image-bundled-plugins`, `docker-image-layer-reuse`, `cloud-image-sentry`, `runner-lockfile-guards` and `runner-image-identity` in `server/src/__tests__`, and `server/scripts/prepare-runner-vendor.test.mjs`: 218 tests in 11 files pass on Linux; on macOS 217 pass and 1 is skipped (it needs bash 4.4). - `node --test .github/scripts/tests/*.test.mjs scripts/merge-group-image.test.mjs scripts/reuse-canary-image.test.mjs scripts/cloud-source-verification.test.mjs scripts/standard-image-contract.test.mjs scripts/preview-artifacts.test.mjs scripts/__tests__/release-verify-workflow.test.mjs scripts/__tests__/release-dry-run-notes.test.mjs`: 991 of 991 pass on both. - The changed test file typechecks with the options of `server/src/__tests__/tsconfig.json`. Read-only checks against the real services: - The lookup, with no credential, answered `published` for the inputs `d4df566f…af00` and `0e6662ad…d1ca`, with the index digests that `master` published, and `absent` for a digest that does not exist. - The real answer of the Actions API for the `runner-image.yml` runs of four `master` commits went through the wait, with a clock that does not sleep. Three completed runs ended it at once. A queued run ended it at the limit of 40 minutes from its creation time. A commit with no run ended it after the 2 minutes for a run that is not listed. - Of the 60 newest runs of `runner-image.yml`, the filter accepted the 19 `push` runs on `master` and none of the 41 pull-request runs. - `runner-image-resolve.mjs inputs` ran on a clean export of the tree of the next pull request, with a `docker-container` builder. The answer was `lock: current` and the inputs digest `c4f9d089…34f0`. The `Dockerfile` of #21332 declares the argument, so the answer was not `unsupported`. The same command on a tree with one changed range in `packages/paperclip-runner/package.json` answered `lock: behind`, and `resolve` then answered `inline (lock-behind)`. Never run: - `resolve --wait` in a workflow. No workflow calls it in this pull request. - The full test suite and the full typecheck. CI must supply them. ## Risks - `resolve` now prints a notice for every `inline` answer. The report-only job in `docker.yml` therefore shows one notice on each `master` push whose Runner image is not published yet, until the next pull request replaces the job. Nothing reads that job. - `inputs` answers `unsupported` for a tree whose `Dockerfile` does not declare `ARG PAPERCLIP_RUNNER_EXPECT_INPUTS_DIGEST` at the start of a line. #21332 adds that line; a later edit that moves or renames it turns every answer to `inline`. - The wait is bounded by time from the push, not by its own duration. A build that starts more than 40 minutes after the push looks once and does not wait. - A registry that does not answer adds at most about 3 minutes to one lookup, because the registry client retries. A caller must give the step more than 40 minutes. The next pull request gives it 55. > For core feature work, check [`ROADMAP.md`](ROADMAP.md) first and discuss it in `#dev` before opening the PR. Feature PRs that overlap with planned core work may need to be redirected — check the roadmap first. See `CONTRIBUTING.md`. ## Model Used - Claude Fable 5.2 (`claude-fable-5-2`), Anthropic, used through Claude Code with tool use (shell, file edits, read-only calls to the GitHub API and the container registry). ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have checked ROADMAP.md and confirmed this PR does not duplicate planned core work - [x] I have searched GitHub for duplicate or related PRs and linked them above - [x] I have either (a) linked existing issues with `Fixes: #` / `Closes #` / `Refs #` OR (b) described the issue in-PR following the relevant issue template - [x] I have not referenced internal/instance-local Paperclip issues or links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip` URLs) - [x] My branch name describes the change (e.g. `docs/...`, `fix/...`) and contains no internal Paperclip ticket id or instance-derived details - [x] I have run tests locally and they pass - [x] I have added or updated tests where applicable - [x] I have updated relevant documentation to reflect my changes - [x] I have considered and documented any risks above - [x] All Paperclip CI gates are green - [x] Greptile is 5/5 with no open P2s, recommendations, or follow-ups - [x] I will address all Greptile and reviewer comments before requesting merge 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
298 lines
15 KiB
JavaScript
298 lines
15 KiB
JavaScript
#!/usr/bin/env node
|
|
// Which Runner an image build uses: the published Runner image of this tree's
|
|
// inputs (ghcr.io/paperclipai/paperclip-runner), or the Runner the build makes
|
|
// itself, inline. See doc/runner-image-contract.md.
|
|
//
|
|
// inputs --dir <directory> exports the Runner build context of the
|
|
// checkout, checks its lockfile and, when that is current, computes
|
|
// the inputs digest in the build. Needs Docker and pnpm, reads no
|
|
// credential. Run it on the committed files, before any lockfile
|
|
// refresh. The directory must be new or empty
|
|
// resolve --dir <directory> looks up `inputs-<digest>` for the result of
|
|
// `inputs` and reports `published`, with both variants pinned by
|
|
// index digest, or `inline`. Runs no build
|
|
//
|
|
// Every answer short of a complete publication of exactly these inputs is
|
|
// `inline`: a refused, failed or unreachable lookup included. Registry
|
|
// credentials are those of runner-image-publish.mjs.
|
|
|
|
import assert from "node:assert/strict";
|
|
import { spawnSync } from "node:child_process";
|
|
import { randomUUID } from "node:crypto";
|
|
import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
|
|
import path from "node:path";
|
|
import { fileURLToPath, pathToFileURL } from "node:url";
|
|
import { RUNNER_IMAGE_NAME, RUNNER_IMAGE_PLATFORMS } from "./runner-image-identity.mjs";
|
|
import {
|
|
environmentCredentials, readRunnerImageManifest, runnerImageTags, runnerLockState, runnerPublicationState,
|
|
} from "./runner-image-publish.mjs";
|
|
|
|
export const RUNNER_IMAGE_LABEL = "io.paperclip.runner.image";
|
|
export const RUNNER_INPUTS_DIGEST_LABEL = "io.paperclip.runner.inputs-digest";
|
|
export const RUNNER_EXPECT_INPUTS_DIGEST_ARGUMENT = "PAPERCLIP_RUNNER_EXPECT_INPUTS_DIGEST";
|
|
export const RUNNER_IMAGE_WAIT_MINUTES = 40;
|
|
export const RUNNER_IMAGE_WAIT = Object.freeze({
|
|
limitMs: RUNNER_IMAGE_WAIT_MINUTES * 60_000, listingMs: 2 * 60_000, pollMs: 30_000, failures: 3,
|
|
});
|
|
export const RUNNER_IMAGE_WORKFLOW_PATH = ".github/workflows/runner-image.yml";
|
|
const REPOSITORY = "paperclipai/paperclip";
|
|
const REPOSITORY_ID = 1170821064;
|
|
const WAITS_FOR = Object.freeze(["absent", "incomplete"]);
|
|
const INPUTS_FILE = "runner-image-inputs.json";
|
|
const HEX_64 = /^[0-9a-f]{64}$/;
|
|
const DIGEST = /^sha256:[0-9a-f]{64}$/;
|
|
const REVISION = /^[0-9a-f]{40}$/;
|
|
const EXPECTS_INPUTS_DIGEST = new RegExp(`^ARG ${RUNNER_EXPECT_INPUTS_DIGEST_ARGUMENT}(?:=.*)?$`, "m");
|
|
const message = (error) => (error instanceof Error ? error.message : String(error));
|
|
|
|
/**
|
|
* @param {{
|
|
* repoRoot: string,
|
|
* directory: string,
|
|
* run?: (command: string, args: string[], options: object) => { status: number | null, error?: Error },
|
|
* lockState?: typeof runnerLockState,
|
|
* }} input
|
|
* @returns {{ consumable: boolean, lock: "current" | "behind" | null, detail: string, inputsDigest: string | null }}
|
|
*/
|
|
export function readRunnerInputs({ repoRoot, directory, run = spawnSync, lockState = runnerLockState }) {
|
|
assert.ok(!existsSync(directory) || readdirSync(directory).length === 0, `${directory} is not empty`);
|
|
mkdirSync(directory, { recursive: true });
|
|
const write = (inputs) => {
|
|
writeFileSync(path.join(directory, INPUTS_FILE), `${JSON.stringify(inputs, null, 2)}\n`);
|
|
return inputs;
|
|
};
|
|
if (!EXPECTS_INPUTS_DIGEST.test(readFileSync(path.join(repoRoot, "Dockerfile"), "utf8"))) {
|
|
return write({
|
|
consumable: false, lock: null, inputsDigest: null,
|
|
detail: `the Dockerfile declares no ${RUNNER_EXPECT_INPUTS_DIGEST_ARGUMENT} argument, so its build cannot check a Runner it is given`,
|
|
});
|
|
}
|
|
const build = (target, name) => {
|
|
const destination = path.join(directory, name);
|
|
// Build output goes to stderr: stdout carries only this command's result.
|
|
const result = run("docker", ["buildx", "build", "--target", target, "--output", `type=local,dest=${destination}`, repoRoot],
|
|
{ stdio: ["ignore", 2, 2] });
|
|
if (result.error) throw result.error;
|
|
assert.equal(result.status, 0, `docker buildx build --target ${target} failed (exit ${result.status})`);
|
|
return destination;
|
|
};
|
|
const lock = lockState(build("runner-artifacts-context", "context"));
|
|
let inputsDigest = null;
|
|
if (lock.state === "current") {
|
|
const identity = path.join(build("runner-artifacts-identity", "identity"), "runner-image-identity.json");
|
|
inputsDigest = JSON.parse(readFileSync(identity, "utf8")).digest;
|
|
assert.match(inputsDigest ?? "", HEX_64, "The build computed no inputs digest");
|
|
}
|
|
return write({ consumable: true, lock: lock.state, detail: lock.detail, inputsDigest });
|
|
}
|
|
|
|
function indexProblem(bytes, inputsDigest) {
|
|
const index = JSON.parse(bytes.toString("utf8"));
|
|
const named = index.annotations?.[RUNNER_INPUTS_DIGEST_LABEL];
|
|
if (named !== inputsDigest) return `the full index names the inputs ${named ?? "(none)"}`;
|
|
for (const platform of RUNNER_IMAGE_PLATFORMS) {
|
|
const [os, architecture] = platform.split("/");
|
|
const found = Array.isArray(index.manifests) && index.manifests.some((entry) =>
|
|
entry?.platform?.os === os && entry.platform.architecture === architecture && DIGEST.test(entry.digest ?? ""));
|
|
if (!found) return `the full index has no ${platform} image`;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* @param {{ consumable: boolean, lock: "current" | "behind" | null, detail?: string, inputsDigest: string | null }} inputs
|
|
* @param {{ read?: typeof readRunnerImageManifest, credentials?: { username: string, password: string } | null }} [options]
|
|
*/
|
|
export async function resolveRunnerImage({ consumable, lock, detail: inputsDetail, inputsDigest }, { read = readRunnerImageManifest, credentials = null } = {}) {
|
|
const inline = (reason, detail) => ({
|
|
mode: "inline", reason, detail, inputsDigest: inputsDigest ?? "", image: "", slimImage: "", buildContexts: [], labels: [], buildArgs: [],
|
|
});
|
|
if (consumable !== true) return inline("unsupported", inputsDetail ?? "the build of this tree cannot check a Runner it is given");
|
|
assert.ok(lock === "current" || lock === "behind", "The lockfile state must be current or behind");
|
|
if (lock === "behind") return inline("lock-behind", "pnpm-lock.yaml is behind the Runner's manifests, so no image is published for this tree");
|
|
assert.match(inputsDigest ?? "", HEX_64, "A tree with a current lockfile needs an inputs digest");
|
|
try {
|
|
const { full: fullTag } = runnerImageTags(inputsDigest);
|
|
let fullIndex = null;
|
|
const publication = await runnerPublicationState(inputsDigest, async (reference) => {
|
|
const result = await read(reference, { credentials });
|
|
if (reference === fullTag && result.state === "present") fullIndex = result.bytes;
|
|
return result;
|
|
});
|
|
if (publication.state !== "published") return inline(publication.state, publication.detail);
|
|
const problem = indexProblem(fullIndex, inputsDigest);
|
|
if (problem) return inline("mismatch", `${fullTag}: ${problem}`);
|
|
const image = `${RUNNER_IMAGE_NAME}@${publication.full}`;
|
|
const slimImage = `${RUNNER_IMAGE_NAME}@${publication.slim}`;
|
|
return {
|
|
mode: "published", reason: "published", detail: publication.detail, inputsDigest, image, slimImage,
|
|
buildContexts: [`runner-artifacts=docker-image://${image}`, `runner-artifacts-slim=docker-image://${slimImage}`],
|
|
labels: [`${RUNNER_IMAGE_LABEL}=${image}`, `${RUNNER_INPUTS_DIGEST_LABEL}=${inputsDigest}`],
|
|
buildArgs: [`${RUNNER_EXPECT_INPUTS_DIGEST_ARGUMENT}=${inputsDigest}`],
|
|
};
|
|
} catch (error) {
|
|
return inline("unknown", `the lookup failed: ${message(error)}`);
|
|
}
|
|
}
|
|
|
|
export function runnerImageRuns(runs, sha) {
|
|
return runs.filter((run) => run?.head_sha === sha && run.event === "push" && run.head_branch === "master"
|
|
&& run.path === RUNNER_IMAGE_WORKFLOW_PATH && run.repository?.id === REPOSITORY_ID && run.head_repository?.id === REPOSITORY_ID);
|
|
}
|
|
|
|
export async function listRunnerImageRuns(sha, { token = "", fetchImpl = fetch } = {}) {
|
|
assert.match(sha ?? "", REVISION, "The commit must be a full SHA");
|
|
assert.ok(token, "A token is needed to list workflow runs");
|
|
const response = await fetchImpl(
|
|
`https://api.github.com/repos/${REPOSITORY}/actions/workflows/runner-image.yml/runs?head_sha=${sha}&event=push&branch=master&per_page=30`,
|
|
{ redirect: "error", headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" }, signal: AbortSignal.timeout(30_000) },
|
|
);
|
|
if (!response.ok) {
|
|
await response.body?.cancel();
|
|
throw new Error(`GitHub API: HTTP ${response.status}`);
|
|
}
|
|
const body = await response.json();
|
|
assert.ok(Array.isArray(body?.workflow_runs), "GitHub API returned no list of workflow runs");
|
|
return body.workflow_runs;
|
|
}
|
|
|
|
export async function waitForRunnerImage({
|
|
sha, listRuns, resolve, now = Date.now, sleep = (ms) => new Promise((done) => setTimeout(done, ms)), limits = RUNNER_IMAGE_WAIT,
|
|
}) {
|
|
const started = now();
|
|
const waited = () => `${Math.round((now() - started) / 60_000)} min`;
|
|
let failures = 0;
|
|
for (;;) {
|
|
let runs = null;
|
|
try {
|
|
runs = runnerImageRuns(await listRuns(sha), sha);
|
|
failures = 0;
|
|
} catch (error) {
|
|
failures += 1;
|
|
if (failures >= limits.failures) {
|
|
return { outcome: "unknown", detail: `could not list the Runner image runs of ${sha} (${message(error)})` };
|
|
}
|
|
}
|
|
if (runs?.length === 0 && now() - started >= limits.listingMs) {
|
|
return { outcome: "not-listed", detail: `no Runner image run of a master push of ${sha} was listed in ${waited()}` };
|
|
}
|
|
if (runs?.length > 0) {
|
|
const named = runs.map((run) => `${run.html_url ?? run.id} (${run.status === "completed" ? run.conclusion : run.status})`).join(", ");
|
|
if (runs.every((run) => run.status === "completed")) {
|
|
return { outcome: "completed", detail: `waited ${waited()} for the Runner image run ${named}` };
|
|
}
|
|
const resolved = await resolve();
|
|
if (resolved.mode === "published") return { outcome: "published", resolved, detail: `waited ${waited()} for the Runner image run ${named}` };
|
|
const pushed = Math.min(started, ...runs.map((run) => Date.parse(run.created_at)).filter(Number.isFinite));
|
|
if (now() - pushed >= limits.limitMs) {
|
|
return {
|
|
outcome: "limit",
|
|
detail: `the Runner image run ${named} did not finish within ${Math.round(limits.limitMs / 60_000)} min of the push, after a wait of ${waited()}`,
|
|
};
|
|
}
|
|
}
|
|
await sleep(limits.pollMs);
|
|
}
|
|
}
|
|
|
|
export async function resolveRunnerImageAfterWait({ resolve, wait }) {
|
|
const first = await resolve();
|
|
if (!WAITS_FOR.includes(first.reason)) return first;
|
|
const waited = await wait(resolve);
|
|
const last = waited.resolved ?? await resolve();
|
|
return { ...last, detail: `${last.detail}; ${waited.detail}` };
|
|
}
|
|
|
|
/** @param {string[]} argv */
|
|
export function parseResolveArguments(argv) {
|
|
const [command, flag, directory, ...rest] = argv;
|
|
const wait = command === "resolve" && rest.length === 1 && rest[0] === "--wait";
|
|
if (!["inputs", "resolve"].includes(command) || flag !== "--dir" || !directory || directory.startsWith("--") || (rest.length > 0 && !wait)) {
|
|
throw new Error("Usage: runner-image-resolve.mjs inputs --dir <directory> | resolve --dir <directory> [--wait]");
|
|
}
|
|
return { command, directory: path.resolve(directory), wait };
|
|
}
|
|
|
|
/**
|
|
* @param {string[]} argv
|
|
* @param {{
|
|
* env?: NodeJS.ProcessEnv, repoRoot?: string, read?: typeof readRunnerImageManifest, readInputs?: typeof readRunnerInputs,
|
|
* log?: (line: string) => void, waitFor?: typeof waitForRunnerImage, fetchImpl?: typeof fetch,
|
|
* }} [options]
|
|
* @returns {Promise<Record<string, string>>}
|
|
*/
|
|
export async function runResolveCommand(argv, {
|
|
env = process.env,
|
|
repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."),
|
|
read = readRunnerImageManifest,
|
|
readInputs = readRunnerInputs,
|
|
log = console.error,
|
|
waitFor = waitForRunnerImage,
|
|
fetchImpl = fetch,
|
|
} = {}) {
|
|
const { command, directory, wait } = parseResolveArguments(argv);
|
|
if (command === "inputs") {
|
|
const inputs = readInputs({ repoRoot, directory });
|
|
return { lock: inputs.lock ?? "", inputs_digest: inputs.inputsDigest ?? "" };
|
|
}
|
|
const inputs = JSON.parse(readFileSync(path.join(directory, INPUTS_FILE), "utf8"));
|
|
const resolve = () => resolveRunnerImage(inputs, { read, credentials: environmentCredentials(env) });
|
|
const sha = env.GITHUB_SHA;
|
|
const token = env.GITHUB_TOKEN;
|
|
const resolved = wait
|
|
? await resolveRunnerImageAfterWait({
|
|
resolve,
|
|
wait: async () => {
|
|
if (!REVISION.test(sha ?? "") || !token) return { outcome: "unknown", detail: "no commit or no token to find its Runner image run with" };
|
|
try {
|
|
return await waitFor({ sha, resolve, listRuns: (commit) => listRunnerImageRuns(commit, { token, fetchImpl }) });
|
|
} catch (error) {
|
|
return { outcome: "unknown", detail: `the wait failed: ${message(error)}` };
|
|
}
|
|
},
|
|
})
|
|
: await resolve();
|
|
log(`Runner image: ${resolved.mode} (${resolved.reason}: ${resolved.detail})`);
|
|
if (resolved.mode === "inline") {
|
|
log(`::notice title=Runner built inline::This image build makes its own Runner (${resolved.reason}: ${resolved.detail}).`);
|
|
}
|
|
if (env.GITHUB_STEP_SUMMARY) {
|
|
appendFileSync(env.GITHUB_STEP_SUMMARY, [
|
|
`Runner for an image build of this tree: **${resolved.mode}** (\`${resolved.reason}\`: ${resolved.detail})`,
|
|
`- inputs digest: ${resolved.inputsDigest ? `\`${resolved.inputsDigest}\`` : "not computed"}`,
|
|
...(resolved.mode === "published" ? [`- full image: \`${resolved.image}\``, `- slim image: \`${resolved.slimImage}\``] : []),
|
|
"",
|
|
].join("\n"));
|
|
}
|
|
return {
|
|
mode: resolved.mode,
|
|
reason: resolved.reason,
|
|
inputs_digest: resolved.inputsDigest,
|
|
image: resolved.image,
|
|
slim_image: resolved.slimImage,
|
|
build_contexts: resolved.buildContexts.join("\n"),
|
|
labels: resolved.labels.join("\n"),
|
|
build_args: resolved.buildArgs.join("\n"),
|
|
};
|
|
}
|
|
|
|
/** @param {Record<string, string>} values written as $GITHUB_OUTPUT takes them, a value of several lines included */
|
|
export function formatOutputs(values) {
|
|
return Object.entries(values).map(([name, value]) => {
|
|
if (!value.includes("\n")) return `${name}=${value}`;
|
|
const delimiter = `end-${randomUUID()}`;
|
|
return `${name}<<${delimiter}\n${value}\n${delimiter}`;
|
|
}).join("\n");
|
|
}
|
|
|
|
if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
|
|
try {
|
|
const text = formatOutputs(await runResolveCommand(process.argv.slice(2)));
|
|
console.log(text);
|
|
if (process.env.GITHUB_OUTPUT) appendFileSync(process.env.GITHUB_OUTPUT, `${text}\n`);
|
|
} catch (error) {
|
|
console.error(error instanceof Error ? error.message : String(error));
|
|
process.exit(1);
|
|
}
|
|
}
|