pi-harness-runtime 0.10.12 → 0.10.13

package/scripts/gist-poll.sh

@@ -0,0 +1,127 @@
+#!/bin/bash
+# =============================================================================
+# gist-poll.sh — Client clipboard poller for pi-harness-runtime Gist sync
+# =============================================================================
+# Cross-platform clipboard sync via GitHub Gist.
+# Run this on Mac/iPad/Ubuntu to receive clipboard content from the server.
+#
+# Setup:
+#   1. Run /github-login on the server (pi session)
+#   2. Copy Gist ID from the confirmation message
+#   3. Export GITHUB_TOKEN and GIST_ID below, or pass as arguments
+#   4. Run this script: bash gist-poll.sh
+#
+# Usage:
+#   bash gist-poll.sh                    # Uses env vars or prompts
+#   bash gist-poll.sh <token> <gist-id> # Arguments
+#   GITHUB_TOKEN=xxx GIST_ID=xxx bash gist-poll.sh  # Env vars
+# =============================================================================
+
+set -euo pipefail
+
+# ── Config ────────────────────────────────────────────────────────────────────
+POLL_INTERVAL="${POLL_INTERVAL:-2}" # seconds between polls
+TIMEOUT_SEC=10                      # curl timeout
+
+# ── Colors ─────────────────────────────────────────────────────────────────────
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+log_info() { echo -e "${GREEN}[gist-poll]${NC} $*"; }
+log_warn() { echo -e "${YELLOW}[gist-poll]${NC} $*" >&2; }
+log_error() { echo -e "${RED}[gist-poll]${NC} $*" >&2; }
+
+# ── Argument parsing ───────────────────────────────────────────────────────────
+GITHUB_TOKEN="${1:-${GITHUB_TOKEN:-}}"
+GIST_ID="${2:-${GIST_ID:-}}"
+
+if [[ -z "$GITHUB_TOKEN" ]] || [[ -z "$GIST_ID" ]]; then
+	echo ""
+	echo "=== pi-harness-runtime Gist Clipboard Poller ==="
+	echo ""
+	echo "Configure one of:"
+	echo "  1. Export variables: export GITHUB_TOKEN=xxx GIST_ID=xxx"
+	echo "  2. Pass arguments:  bash gist-poll.sh <token> <gist-id>"
+	echo ""
+	echo "Get these from the /github-login confirmation message on the server."
+	echo ""
+	echo "The /github-login command shows the Gist URL like:"
+	echo "  https://gist.github.com/<username>/<GIST_ID>"
+	echo ""
+	echo "Example:"
+	echo "  bash gist-poll.sh ghp_xxxxx abc123def456"
+	echo ""
+	exit 1
+fi
+
+# ── Detect clipboard tool ───────────────────────────────────────────────────────
+detect_clipboard_tool() {
+	if command -v pbcopy >/dev/null 2>&1; then
+		echo "pbcopy"
+	elif command -v xclip >/dev/null 2>&1; then
+		echo "xclip"
+	elif command -v xsel >/dev/null 2>&1; then
+		echo "xsel"
+	else
+		log_error "No clipboard tool found (pbcopy, xclip, xsel)"
+		log_error "Install one of: pbcopy (macOS), xclip (Linux), xsel (Linux)"
+		exit 1
+	fi
+}
+
+write_clipboard() {
+	local content="$1"
+	local tool
+	tool=$(detect_clipboard_tool)
+
+	case "$tool" in
+	pbcopy)
+		echo "$content" | pbcopy
+		;;
+	xclip)
+		echo "$content" | xclip -selection clipboard -in
+		;;
+	xsel)
+		echo "$content" | xsel --clipboard --input
+		;;
+	esac
+	log_info "Updated clipboard (${tool}): ${#content} chars"
+}
+
+# ── Fetch from Gist ───────────────────────────────────────────────────────────
+fetch_gist_content() {
+	curl -s \
+		--max-time "$TIMEOUT_SEC" \
+		-H "Authorization: Bearer $GITHUB_TOKEN" \
+		-H "Accept: application/vnd.github+json" \
+		-H "X-GitHub-Api-Version: 2022-11-28" \
+		"https://api.github.com/gists/$GIST_ID" |
+		grep -o '"content":"[^"]*"' |
+		sed 's/"content":"//;s/"$//' |
+		head -1
+}
+
+# ── Main loop ─────────────────────────────────────────────────────────────────
+log_info "Starting Gist clipboard poller..."
+log_info "Poll interval: ${POLL_INTERVAL}s"
+log_info "Gist: https://gist.github.com/${GIST_ID}"
+log_info "Clipboard tool: $(detect_clipboard_tool)"
+log_info ""
+log_info "Press Ctrl+C to stop."
+log_info "Any text copied on the server (Ctrl+Shift+C) will appear here."
+
+LAST_CONTENT=""
+
+while true; do
+	CURRENT_CONTENT=$(fetch_gist_content 2>/dev/null || echo "")
+
+	if [[ -n "$CURRENT_CONTENT" ]] && [[ "$CURRENT_CONTENT" != "$LAST_CONTENT" ]]; then
+		LAST_CONTENT="$CURRENT_CONTENT"
+		write_clipboard "$CURRENT_CONTENT"
+	fi
+
+	sleep "$POLL_INTERVAL"
+done

package/scripts/release/actions-monitor.ts

@@ -0,0 +1,357 @@
+#!/usr/bin/env bun
+/**
+ * GitHub Actions Monitor
+ *
+ * Polls a GitHub Actions run and watches it to completion.
+ * Uses gh CLI which must be authenticated: gh auth login
+ *
+ * Usage:
+ *   bun scripts/release/actions-monitor.ts --owner user --repo repo --run 123
+ *   bun scripts/release/actions-monitor.ts --owner user --repo repo (latest run on current branch)
+ *   bun scripts/release/actions-monitor.ts --detach         → fire and forget
+ */
+
+import { execSync } from "node:child_process";
+
+const DEFAULT_POLL_INTERVAL_MS = 10_000;
+const MAX_POLL_MINUTES = 60;
+
+/** Raw action run from GitHub API */
+interface ActionRun {
+	id: number;
+	name: string;
+	status: "queued" | "in_progress" | "completed";
+	conclusion:
+		| "success"
+		| "failure"
+		| "cancelled"
+		| "skipped"
+		| "timed_out"
+		| "action_required"
+		| null;
+	html_url: string;
+	created_at: string;
+	updated_at: string;
+	head_branch: string;
+	run_number: number;
+	event: string;
+}
+
+interface MonitorOptions {
+	owner?: string;
+	repo?: string;
+	runId?: number;
+	pollIntervalMs?: number;
+	maxMinutes?: number;
+	verbose?: boolean;
+	detach?: boolean;
+}
+
+interface RunStatus {
+	status: string;
+	conclusion: string | null;
+	url: string;
+	runId: number;
+	name: string;
+	branch: string;
+	runNumber: number;
+	createdAt: string;
+	updatedAt: string;
+}
+
+// ── gh CLI helpers ────────────────────────────────────────────────────────────
+
+/** Execute gh command, return { stdout, status }. Never throws. */
+function ghQuiet(args: string[]): { stdout: string; status: number } {
+	try {
+		const stdout = execSync(`gh ${args.join(" ")}`, {
+			encoding: "utf-8",
+			timeout: 15_000,
+			maxBuffer: 10 * 1024 * 1024,
+		}).trim();
+		return { stdout, status: 0 };
+	} catch (e) {
+		const err = e as { status?: number; stderr?: string };
+		return { stdout: err.stderr ?? "", status: err.status ?? 1 };
+	}
+}
+
+/** Call gh api and parse JSON. Returns null on failure. */
+function ghApi<T>(path: string, extraArgs: string[] = []): T | null {
+	const { stdout, status } = ghQuiet(["api", path, ...extraArgs]);
+	if (status !== 0 || !stdout) return null;
+	try {
+		return JSON.parse(stdout) as T;
+	} catch {
+		return null;
+	}
+}
+
+// ── Repo / branch detection ────────────────────────────────────────────────────
+
+function getCurrentBranch(): string {
+	try {
+		return execSync("git branch --show-current", {
+			encoding: "utf-8",
+			timeout: 5000,
+		}).trim();
+	} catch {
+		return "develop";
+	}
+}
+
+function getRemoteRepo(): { owner: string; repo: string } | null {
+	const { stdout, status } = ghQuiet([
+		"repo",
+		"view",
+		"--json",
+		"owner,name",
+		"-q",
+		"{owner:.owner.login,repo:.name}",
+	]);
+	if (status !== 0) return null;
+	try {
+		const parsed = JSON.parse(stdout);
+		return { owner: parsed.owner, repo: parsed.repo };
+	} catch {
+		return null;
+	}
+}
+
+// ── Action run queries ─────────────────────────────────────────────────────────
+
+function getLatestRun(
+	owner: string,
+	repo: string,
+	branch?: string,
+): ActionRun | null {
+	const runs = ghApi<{ workflow_runs: ActionRun[] }>(
+		`repos/${owner}/${repo}/actions/runs`,
+		["-F", "per_page=1", ...(branch ? ["-F", `branch=${branch}`] : [])],
+	);
+	return runs?.workflow_runs?.[0] ?? null;
+}
+
+function getRunStatus(
+	owner: string,
+	repo: string,
+	runId: number,
+): RunStatus | null {
+	const run = ghApi<ActionRun>(
+		`repos/${owner}/${repo}/actions/runs/${runId}`,
+	);
+	if (!run) return null;
+	return {
+		status: run.status,
+		conclusion: run.conclusion,
+		url: run.html_url,
+		runId: run.id,
+		name: run.name,
+		branch: run.head_branch,
+		runNumber: run.run_number,
+		createdAt: run.created_at,
+		updatedAt: run.updated_at,
+	};
+}
+
+// ── Formatting ─────────────────────────────────────────────────────────────────
+
+function formatDuration(startIso: string): string {
+	const start = new Date(startIso).getTime();
+	const elapsed = Date.now() - start;
+	const min = Math.floor(elapsed / 60_000);
+	const sec = Math.floor((elapsed % 60_000) / 1000);
+	return min > 0 ? `${min}m ${sec}s` : `${sec}s`;
+}
+
+function formatConclusion(c: string | null): string {
+	switch (c) {
+		case "success":
+			return "✅ Success";
+		case "failure":
+			return "❌ Failed";
+		case "cancelled":
+			return "🚫 Cancelled";
+		case "timed_out":
+			return "⏱ Timed out";
+		case "skipped":
+			return "⏭ Skipped";
+		case "action_required":
+			return "⚠ Action required";
+		default:
+			return `? ${c ?? "unknown"}`;
+	}
+}
+
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧"];
+
+async function sleep(ms: number): Promise<void> {
+	return new Promise((r) => setTimeout(r, ms));
+}
+
+// ── Monitor ────────────────────────────────────────────────────────────────────
+
+/**
+ * Poll a GitHub Actions run until completion.
+ * Returns { conclusion, duration } when done (success, failure, or timeout).
+ */
+export async function monitorRun(
+	owner: string,
+	repo: string,
+	runId: number,
+	options: MonitorOptions = {},
+): Promise<{ conclusion: string | null; duration: number }> {
+	const pollMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+	const maxMs = (options.maxMinutes ?? MAX_POLL_MINUTES) * 60 * 1000;
+	const startTime = Date.now();
+	let spin = 0;
+	let lastStatus = "";
+
+	while (Date.now() - startTime < maxMs) {
+		const status = getRunStatus(owner, repo, runId);
+		if (!status) {
+			console.warn(`[actions-monitor] Run ${runId} not found`);
+			break;
+		}
+
+		const elapsed = formatDuration(status.createdAt);
+
+		if (status.status !== lastStatus) {
+			if (options.verbose) {
+				console.log(`[actions-monitor] Status: ${status.status}`);
+			}
+			lastStatus = status.status;
+		}
+
+		if (status.status === "completed") {
+			const dur = Date.now() - startTime;
+			console.log(
+				`\n${formatConclusion(status.conclusion)} in ${elapsed} — ${status.url}`,
+			);
+			return { conclusion: status.conclusion, duration: dur };
+		}
+
+		// Still running
+		const dots = ".".repeat((spin % 3) + 1);
+		process.stdout.write(
+			`\r${SPINNER[spin++ % SPINNER.length]} [${elapsed}] ${status.name} #${status.runNumber} (${status.branch}) ${status.status}${dots}   `,
+		);
+
+		await sleep(pollMs);
+	}
+
+	// Timeout
+	const dur = Date.now() - startTime;
+	console.warn(`\n[actions-monitor] Timeout after ${MAX_POLL_MINUTES}m`);
+	return { conclusion: "timed_out", duration: dur };
+}
+
+/**
+ * Find and monitor the latest run for a repo/branch.
+ */
+export async function monitorLatest(
+	owner: string,
+	repo: string,
+	branch: string,
+	options: MonitorOptions = {},
+): Promise<{ runId: number; conclusion: string | null; duration: number } | null> {
+	const run = getLatestRun(owner, repo, branch);
+	if (!run) {
+		console.warn(`[actions-monitor] No runs found for ${branch}`);
+		return null;
+	}
+	console.log(
+		`Found run #${run.run_number} (${run.id}) — ${run.name} on ${run.head_branch}`,
+	);
+	return {
+		runId: run.id,
+		...(await monitorRun(owner, repo, run.id, options)),
+	};
+}
+
+// ── CLI ────────────────────────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+	const args = process.argv.slice(2);
+
+	const opts: MonitorOptions = {
+		pollIntervalMs: DEFAULT_POLL_INTERVAL_MS,
+		maxMinutes: MAX_POLL_MINUTES,
+		verbose: args.includes("--verbose"),
+		detach: args.includes("--detach"),
+	};
+
+	// Parse flags
+	for (const arg of args) {
+		const m = arg.match(/^--owner=(.+)$/);
+		if (m) { opts.owner = m[1]; continue; }
+		const r = arg.match(/^--repo=(.+)$/);
+		if (r) { opts.repo = r[1]; continue; }
+		const runM = arg.match(/^--run=(\d+)$/);
+		if (runM) { opts.runId = parseInt(runM[1], 10); continue; }
+		const pollM = arg.match(/^--poll=(\d+)$/);
+		if (pollM) { opts.pollIntervalMs = parseInt(pollM[1], 10) * 1000; }
+	}
+
+	// Resolve owner/repo from git remote if not provided
+	if (!opts.owner || !opts.repo) {
+		const remote = getRemoteRepo();
+		if (!remote) {
+			console.error(
+				"Error: No GitHub repo found. Use --owner and --repo flags, or run from a git repo.",
+			);
+			process.exit(1);
+		}
+		opts.owner ??= remote.owner;
+		opts.repo ??= remote.repo;
+	}
+
+	if (!opts.owner || !opts.repo) {
+		console.error("Error: --owner and --repo required");
+		process.exit(1);
+	}
+
+	// --detach: just show the run info and exit
+	if (opts.detach) {
+		const branch = getCurrentBranch();
+		const run = getLatestRun(opts.owner, opts.repo, branch);
+		if (run) {
+			console.log(
+				`Run #${run.run_number} (${run.id}) — ${run.name} [${run.status}]`,
+			);
+		} else {
+			console.log("No runs found");
+		}
+		return;
+	}
+
+	if (opts.runId) {
+		console.log(`Monitoring run #${opts.runId}...`);
+		const result = await monitorRun(
+			opts.owner,
+			opts.repo,
+			opts.runId,
+			opts,
+		);
+		process.exit(result.conclusion === "success" ? 0 : 1);
+	} else {
+		const branch = getCurrentBranch();
+		console.log(`Monitoring latest run on branch '${branch}'...`);
+		const result = await monitorLatest(
+			opts.owner,
+			opts.repo,
+			branch,
+			opts,
+		);
+		if (!result) {
+			console.error("No runs found");
+			process.exit(1);
+		}
+		process.exit(result.conclusion === "success" ? 0 : 1);
+	}
+}
+
+main().catch((err) => {
+	console.error("Error:", (err as Error).message);
+	process.exit(1);
+});

package/scripts/release/adapters/base.ts

@@ -0,0 +1,95 @@
+/**
+ * Base release adapter interface.
+ *
+ * All stack-specific adapters implement this interface.
+ * The detector picks the right adapter(s) for the repo.
+ */
+
+export interface AdapterContext {
+	/** Absolute path to the repo root */
+	repoRoot: string;
+	/** Dry-run mode — describe actions without executing */
+	dryRun: boolean;
+	/** Verbose output */
+	verbose: boolean;
+}
+
+export interface VersionManifest {
+	/** Path relative to repoRoot */
+	path: string;
+	/** Current version string (read from file) */
+	version: string;
+	/** Raw content (for re-serialization) */
+	content: string;
+}
+
+export interface BumpResult {
+	/** The new version after bumping */
+	newVersion: string;
+	/** All manifests that were updated */
+	updated: VersionManifest[];
+	/** Description of what was done */
+	actions: string[];
+}
+
+export interface VerificationResult {
+	/** True if verification passed */
+	ok: boolean;
+	/** List of issues found */
+	errors: string[];
+	/** Warnings that don't block release */
+	warnings: string[];
+}
+
+/**
+ * Stack-specific release adapter.
+ *
+ * Each adapter:
+ * 1. Knows which files to inspect/update for its stack
+ * 2. Provides version reading/writing
+ * 3. Provides bump logic (patch/minor/major/custom)
+ * 4. Provides verification rules
+ */
+export interface ReleaseAdapter {
+	/** Unique identifier for this adapter */
+	id: string;
+
+	/** Human-readable name */
+	name: string;
+
+	/**
+	 * Detect whether this adapter applies to the given repo.
+	 * Return a confidence score 0-1. Higher = more confident.
+	 */
+	detect(ctx: AdapterContext): number;
+
+	/**
+	 * Read all version manifests for this stack.
+	 * Returns empty array if no manifests found.
+	 */
+	readManifests(ctx: AdapterContext): Promise<VersionManifest[]>;
+
+	/**
+	 * Bump version in all relevant manifests.
+	 * Returns the new version and list of updated files.
+	 */
+	bump(
+		ctx: AdapterContext,
+		bumpType: "patch" | "minor" | "major" | "prerelease",
+		newVersion?: string,
+	): Promise<BumpResult>;
+
+	/**
+	 * Verify that all manifests are consistent and release is safe.
+	 * Should check: versions match, required files exist, tag is correct.
+	 */
+	verify(
+		ctx: AdapterContext,
+		expectedVersion: string,
+	): Promise<VerificationResult>;
+
+	/**
+	 * Get the canonical version from the most authoritative manifest.
+	 */
+	getCanonicalVersion(ctx: AdapterContext): Promise<string | null>;
+}