318 lines
9.4 KiB
TypeScript
318 lines
9.4 KiB
TypeScript
import { YAML } from "bun";
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Block-style YAML emitter (replaces Bun's flow-style YAML.stringify)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Emit a JavaScript value as properly-formatted block-style YAML.
|
|
* Handles the shapes found in GitHub Actions action.yml files.
|
|
*/
|
|
export function yamlify(value: unknown, indent = 0): string {
|
|
const pad = " ".repeat(indent);
|
|
|
|
if (value === null || value === undefined) return `${pad}null`;
|
|
if (typeof value === "boolean") return `${pad}${value}`;
|
|
if (typeof value === "number") return `${pad}${value}`;
|
|
|
|
if (typeof value === "string") {
|
|
// Multi-line strings use literal block scalar
|
|
if (value.includes("\n")) {
|
|
const lines = value.split("\n");
|
|
const content =
|
|
lines[lines.length - 1] === "" ? lines.slice(0, -1) : lines;
|
|
const indented = content.map((l) => `${pad} ${l}`).join("\n");
|
|
return `${pad}|\n${indented}`;
|
|
}
|
|
// Quote strings that could be ambiguous or contain template expressions
|
|
if (
|
|
value === "true" ||
|
|
value === "false" ||
|
|
value === "null" ||
|
|
value === "yes" ||
|
|
value === "no" ||
|
|
value === "on" ||
|
|
value === "off" ||
|
|
/^[0-9]/.test(value) ||
|
|
/[:{}#&*!|>"'%@`]/.test(value) ||
|
|
value.includes("${{ ")
|
|
) {
|
|
return `${pad}"${value.replace(/"/g, '\\"')}"`;
|
|
}
|
|
return `${pad}${value}`;
|
|
}
|
|
|
|
if (Array.isArray(value)) {
|
|
if (value.length === 0) return `${pad}[]`;
|
|
return value
|
|
.map((item) => {
|
|
if (item === null || item === undefined) return `${pad}- null`;
|
|
if (typeof item === "object" && !Array.isArray(item)) {
|
|
const inner = yamlify(item, indent + 1);
|
|
const lines = inner.split("\n");
|
|
const first = lines[0]!.slice(indent * 2 + 2);
|
|
const rest = lines.slice(1);
|
|
if (rest.length === 0) return `${pad}- ${first}`;
|
|
return [`${pad}- ${first}`, ...rest].join("\n");
|
|
}
|
|
const scalar = yamlify(item, 0).trimStart();
|
|
return `${pad}- ${scalar}`;
|
|
})
|
|
.join("\n");
|
|
}
|
|
|
|
// Object
|
|
const entries = Object.entries(value as Record<string, unknown>);
|
|
if (entries.length === 0) return `${pad}{}`;
|
|
return entries
|
|
.map(([key, val]) => {
|
|
if (val === null || val === undefined) return `${pad}${key}: null`;
|
|
if (typeof val === "object" && !Array.isArray(val)) {
|
|
return `${pad}${key}:\n${yamlify(val, indent + 1)}`;
|
|
}
|
|
if (Array.isArray(val)) {
|
|
return `${pad}${key}:\n${yamlify(val, indent + 1)}`;
|
|
}
|
|
return `${pad}${key}: ${yamlify(val, 0).trimStart()}`;
|
|
})
|
|
.join("\n");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Types
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export interface ActionInput {
|
|
name: string;
|
|
description?: string;
|
|
required?: boolean;
|
|
default?: unknown;
|
|
}
|
|
|
|
export type ActionType = "composite" | "javascript" | "docker" | "unknown";
|
|
|
|
export interface ParsedAction {
|
|
type: ActionType;
|
|
name?: string;
|
|
description?: string;
|
|
inputs: ActionInput[];
|
|
main?: string; // JS action entrypoint
|
|
raw: Record<string, unknown>; // full parsed YAML document
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Parse an action.yml / action.yaml string
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Parse a raw action.yml / action.yaml string using Bun's built-in YAML
|
|
* parser and classify it as composite, JavaScript, or unknown.
|
|
*/
|
|
export function parseAction(raw: string): ParsedAction {
|
|
const doc = (YAML.parse(raw) ?? {}) as Record<string, unknown>;
|
|
|
|
const runs = doc.runs as Record<string, unknown> | undefined;
|
|
const using = runs?.using as string | undefined;
|
|
|
|
let type: ActionType = "unknown";
|
|
let main: string | undefined;
|
|
|
|
if (using === "composite") {
|
|
type = "composite";
|
|
} else if (using === "docker") {
|
|
type = "docker";
|
|
} else if (using && /^node\d+$/.test(using)) {
|
|
type = "javascript";
|
|
main = runs?.main as string | undefined;
|
|
}
|
|
|
|
const inputs: ActionInput[] = [];
|
|
const inputsObj = doc.inputs as
|
|
| Record<string, Record<string, unknown>>
|
|
| undefined;
|
|
if (inputsObj && typeof inputsObj === "object") {
|
|
for (const [name, def] of Object.entries(inputsObj)) {
|
|
if (def && typeof def === "object") {
|
|
inputs.push({
|
|
name,
|
|
description: def.description as string | undefined,
|
|
required: def.required as boolean | undefined,
|
|
default: def.default,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
type,
|
|
name: doc.name as string | undefined,
|
|
description: doc.description as string | undefined,
|
|
inputs,
|
|
main,
|
|
raw: doc,
|
|
};
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Build composite wrapper for JavaScript actions
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Build a composite action.yml wrapper for a JavaScript action.
|
|
*
|
|
* The wrapper exposes the same inputs as the original but delegates to the
|
|
* original action pinned at a specific commit SHA.
|
|
*/
|
|
export function buildJsWrapper(
|
|
action: ParsedAction,
|
|
owner: string,
|
|
repo: string,
|
|
sha: string,
|
|
): string {
|
|
const wrapper: Record<string, unknown> = {};
|
|
|
|
if (action.name) wrapper.name = action.name;
|
|
if (action.description) wrapper.description = action.description;
|
|
|
|
// Rebuild inputs block
|
|
if (action.inputs.length > 0) {
|
|
const inputs: Record<string, unknown> = {};
|
|
for (const input of action.inputs) {
|
|
const def: Record<string, unknown> = {};
|
|
if (input.description !== undefined) def.description = input.description;
|
|
if (input.required !== undefined) def.required = input.required;
|
|
if (input.default !== undefined) def.default = input.default;
|
|
inputs[input.name] = def;
|
|
}
|
|
wrapper.inputs = inputs;
|
|
}
|
|
|
|
// Build the single composite step
|
|
const step: Record<string, unknown> = {
|
|
uses: `${owner}/${repo}@${sha}`,
|
|
};
|
|
|
|
if (action.inputs.length > 0) {
|
|
const withBlock: Record<string, string> = {};
|
|
for (const input of action.inputs) {
|
|
withBlock[input.name] = `\${{ inputs.${input.name} }}`;
|
|
}
|
|
step.with = withBlock;
|
|
}
|
|
|
|
// Append setup-bun + cleanup steps (same as injectCheckout)
|
|
const steps = [step];
|
|
steps.push({
|
|
uses: "oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6",
|
|
});
|
|
steps.push({
|
|
name: "Cleanup Action",
|
|
shell: "bash",
|
|
run: "bun run $GITHUB_ACTION_PATH/index.js",
|
|
if: "always()",
|
|
});
|
|
|
|
wrapper.runs = {
|
|
using: "composite",
|
|
steps,
|
|
};
|
|
|
|
return yamlify(wrapper);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Build composite wrapper for Docker actions
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Build a composite action.yml wrapper for a Docker action.
|
|
* Same structure as buildJsWrapper — wraps the original pinned at a
|
|
* commit SHA, then appends setup-bun + cleanup steps.
|
|
*/
|
|
export function buildDockerWrapper(
|
|
action: ParsedAction,
|
|
owner: string,
|
|
repo: string,
|
|
sha: string,
|
|
): string {
|
|
const wrapper: Record<string, unknown> = {};
|
|
|
|
if (action.name) wrapper.name = action.name;
|
|
if (action.description) wrapper.description = action.description;
|
|
|
|
if (action.inputs.length > 0) {
|
|
const inputs: Record<string, unknown> = {};
|
|
for (const input of action.inputs) {
|
|
const def: Record<string, unknown> = {};
|
|
if (input.description !== undefined) def.description = input.description;
|
|
if (input.required !== undefined) def.required = input.required;
|
|
if (input.default !== undefined) def.default = input.default;
|
|
inputs[input.name] = def;
|
|
}
|
|
wrapper.inputs = inputs;
|
|
}
|
|
|
|
const steps = [
|
|
{
|
|
uses: `${owner}/${repo}@${sha}`,
|
|
with:
|
|
action.inputs.length > 0
|
|
? Object.fromEntries(
|
|
action.inputs.map((i) => [i.name, `\${{ inputs.${i.name} }}`]),
|
|
)
|
|
: undefined,
|
|
},
|
|
{
|
|
uses: "oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6",
|
|
},
|
|
{
|
|
name: "Cleanup Action",
|
|
if: "always()",
|
|
shell: "bash",
|
|
run: "bun run $GITHUB_ACTION_PATH/index.js",
|
|
},
|
|
];
|
|
|
|
wrapper.runs = {
|
|
using: "composite",
|
|
steps,
|
|
};
|
|
|
|
return yamlify(wrapper);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Inject setup-bun + cleanup steps into composite actions
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Parse a composite action.yml and append setup-bun + cleanup steps to the
|
|
* end of `runs.steps`. Returns the unmodified string when the action has
|
|
* no steps or cannot be parsed.
|
|
*/
|
|
export function injectCheckout(raw: string): string {
|
|
let doc: Record<string, unknown>;
|
|
try {
|
|
doc = YAML.parse(raw) as Record<string, unknown>;
|
|
} catch {
|
|
return raw;
|
|
}
|
|
|
|
const runs = doc.runs as Record<string, unknown> | undefined;
|
|
const steps = runs?.steps as Array<Record<string, unknown>> | undefined;
|
|
if (!steps || !Array.isArray(steps)) return raw;
|
|
|
|
steps.push({
|
|
uses: "oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6",
|
|
if: "always()",
|
|
});
|
|
steps.push({
|
|
name: "Cleanup Action",
|
|
if: "always()",
|
|
shell: "bash",
|
|
run: "bun run $GITHUB_ACTION_PATH/index.js",
|
|
});
|
|
|
|
return yamlify(doc);
|
|
}
|