import { appendFileSync, existsSync, readFileSync } from "node:fs";import { dirname, join } from "node:path";import { fileURLToPath } from "node:url";import { $ } from "execa"; /** * Publish context. Resolved once per workflow run by the `context-output` CI * subcommand and passed through every subsequent step via GitHub Actions job * outputs + per-step flags. */export type Trigger = "branch" | "release"; export interface PublishContext {	trigger: Trigger;	/** Resolved version string, never null. */	version: string;	/** npm dist-tag. */	npmTag: string;	/** Short commit sha (7 chars). */	sha: string;	/** Only meaningful when trigger === "release". */	latest: boolean;	/** Branch name. Only set when trigger === "branch". */	branch?: string;	repoRoot: string;} /** Override set accepted by the local release cutter. */export interface ResolveOverrides {	trigger?: Trigger;	version?: string;	latest?: boolean;	branch?: string;	sha?: string;} function findRepoRoot(): string {	if (process.env.GITHUB_WORKSPACE && existsSync(process.env.GITHUB_WORKSPACE)) {		return process.env.GITHUB_WORKSPACE;	}	let dir = dirname(fileURLToPath(import.meta.url));	for (let i = 0; i < 10; i++) {		if (existsSync(join(dir, "pnpm-workspace.yaml"))) return dir;		dir = dirname(dir);	}	throw new Error("Could not locate repo root (no pnpm-workspace.yaml)");} /** * Base for all preview pre-release strings. Hardcoded to `0.0.0` so preview * versions like `0.0.0-my-branch.abc1234` never look like real releases and * always sort below any published `X.Y.Z`. Using a committed `package.json` * version as the base would just embed whatever stale number happened to be * committed there. It has no semantic relationship to the branch being * previewed. */const PREVIEW_BASE_VERSION = "0.0.0"; async function readShortSha(repoRoot: string): Promise<string> {	const envSha = process.env.GITHUB_SHA;	if (envSha) return envSha.slice(0, 7);	const { stdout } = await $({ cwd: repoRoot })`git rev-parse HEAD`;	return stdout.trim().slice(0, 7);} async function readBranchName(repoRoot: string): Promise<string> {	const envRef = process.env.GITHUB_REF_NAME;	if (envRef) return envRef;	const { stdout } = await $({		cwd: repoRoot,	})`git rev-parse --abbrev-ref HEAD`;	return stdout.trim();} /** * Sanitize a branch name into something safe to use as both an npm dist-tag * and a semver prerelease identifier. Lowercases, replaces any * non-alphanumeric character (other than hyphens) with a hyphen, collapses * runs of hyphens, and trims leading/trailing hyphens. */function sanitizeBranch(branch: string): string {	const cleaned = branch		.toLowerCase()		.replace(/[^a-z0-9-]+/g, "-")		.replace(/-+/g, "-")		.replace(/^-+|-+$/g, "");	if (cleaned.length === 0) {		throw new Error(`branch name "${branch}" sanitized to empty string`);	}	return cleaned;} function readInputFromEvent<T = unknown>(name: string): T | undefined {	const path = process.env.GITHUB_EVENT_PATH;	if (!path || !existsSync(path)) return undefined;	try {		const event = JSON.parse(readFileSync(path, "utf-8")) as {			inputs?: Record<string, unknown>;		};		const v = event.inputs?.[name];		return v as T | undefined;	} catch {		return undefined;	}} function parseBoolInput(v: unknown, fallback: boolean): boolean {	if (typeof v === "boolean") return v;	if (typeof v === "string") {		if (v === "true") return true;		if (v === "false") return false;	}	return fallback;} function deriveTrigger(overrides: ResolveOverrides | undefined): Trigger {	if (overrides?.trigger) return overrides.trigger;	const eventName = process.env.GITHUB_EVENT_NAME;	if (eventName === "workflow_dispatch") {		const version = readInputFromEvent<string>("version");		if (typeof version === "string" && version.length > 0) return "release";		return "branch";	}	// Default for local invocation without overrides (unusual): assume release	// so missing fields are caught loudly.	return "release";} function computeNpmTag(	trigger: Trigger,	version: string,	latest: boolean,	branch?: string,): string {	if (trigger === "branch") {		if (!branch) {			throw new Error("branch trigger requires branch to compute npm tag");		}		return sanitizeBranch(branch);	}	// release	if (version.includes("-rc.")) return "rc";	return latest ? "latest" : "next";} function computeVersion(	trigger: Trigger,	base: string,	sha: string,	branch: string | undefined,	overrideVersion: string | undefined,): string {	if (overrideVersion) return overrideVersion;	if (trigger === "branch") {		if (!branch) {			throw new Error("branch trigger requires branch to compute version");		}		return `${base}-${sanitizeBranch(branch)}.${sha}`;	}	throw new Error("release trigger requires an explicit version override");} /** * Resolve the publish context. Pure function of environment + overrides. * Not memoized: each subcommand process re-reads env, and the `context-output` * subcommand exists specifically so downstream steps receive stable values via * `$GITHUB_OUTPUT` / flags instead of re-resolving. */export async function resolveContext(	overrides: ResolveOverrides = {},): Promise<PublishContext> {	const repoRoot = findRepoRoot();	const trigger = deriveTrigger(overrides); 	const sha = overrides.sha ?? (await readShortSha(repoRoot)); 	let branch = overrides.branch;	if (trigger === "branch" && !branch) {		branch = await readBranchName(repoRoot);	} 	// Release version: override > workflow_dispatch input > error.	let version = overrides.version;	if (!version && trigger === "release") {		const input = readInputFromEvent<string>("version");		if (typeof input === "string" && input.length > 0) version = input;	} 	if (trigger !== "release") {		version = computeVersion(			trigger,			PREVIEW_BASE_VERSION,			sha,			branch,			version,		);	} else if (!version) {		throw new Error(			"release trigger requires version (pass --version or workflow_dispatch input)",		);	} 	// Latest: override > workflow_dispatch input > false.	let latest = overrides.latest;	if (latest === undefined) {		const input = readInputFromEvent<unknown>("latest");		latest = parseBoolInput(input, false);	}	if (trigger !== "release") latest = false; 	const npmTag = computeNpmTag(trigger, version, latest, branch); 	return {		trigger,		version,		npmTag,		sha,		latest,		branch,		repoRoot,	};} /** Write every context field to `$GITHUB_OUTPUT` so downstream steps read via needs.*. */export function writeContextToGithubOutput(ctx: PublishContext): void {	const path = process.env.GITHUB_OUTPUT;	if (!path) {		// When invoked locally for debugging, print to stdout in the same format.		console.log(`trigger=${ctx.trigger}`);		console.log(`version=${ctx.version}`);		console.log(`npm_tag=${ctx.npmTag}`);		console.log(`sha=${ctx.sha}`);		console.log(`latest=${ctx.latest}`);		if (ctx.branch !== undefined) console.log(`branch=${ctx.branch}`);		return;	}	const lines = [		`trigger=${ctx.trigger}`,		`version=${ctx.version}`,		`npm_tag=${ctx.npmTag}`,		`sha=${ctx.sha}`,		`latest=${ctx.latest}`,	];	if (ctx.branch !== undefined) lines.push(`branch=${ctx.branch}`);	// Append (do not overwrite) in case other steps also wrote to GITHUB_OUTPUT.	appendFileSync(path, `${lines.join("\n")}\n`);}