dev-loops 0.6.0 → 0.7.2

package/scripts/loop/detect-stale-runner.mjs

@@ -1,265 +0,0 @@
-#!/usr/bin/env node
-import process from "node:process";
-import { buildParseError, formatCliError, isDirectCliRun } from "../_core-helpers.mjs";
-import { parsePrNumber, requireTokenValue } from "../_cli-primitives.mjs";
-import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
-import { resolveRunId as resolveEnvRunId } from "@dev-loops/core/loop/run-context";
-import { parseArgs } from "node:util";
-import {
-  detectStaleRunner,
-  STALE_RUNNER_ERROR,
-} from "./_stale-runner-detection.mjs";
-const USAGE = `Usage: detect-stale-runner.mjs --repo <owner/name> --pr <number>
-Detect whether the active runner for a PR is stale or has received an exit
-signal. Fails closed with status "stale_runner" or "exit_signal_recorded" so
-the pre-merge guard can refuse to proceed.
-Required:
-  --repo <owner/name>   Repository slug (e.g. owner/repo)
-  --pr <number>         Pull request number
-Optional:
-  --stale-runner-max-age-ms <ms>
-                        Override the staleness threshold (default 30 minutes,
-                        or $DEVLOOPS_STALE_RUNNER_MAX_AGE_MS).
-  --run-id <id>         Override the active run id (default: read from
-                        DEVLOOPS_RUN_ID). When supplied, the detector additionally
-                        verifies the current run id is still the active owner.
-Output (stdout, JSON; always includes staleRunnerCheck):
-  {
-    "ok": true,
-    "repo": "owner/repo",
-    "pr": 17,
-    "status": "fresh_runner",
-    "activeRun": { "runId": "...", "claimedAt": "...", "updatedAt": "..." },
-    "staleRunnerCheck": {
-      "ok": true,
-      "failures": []
-    }
-  }
-  or on failure:
-  {
-    "ok": false,
-    "error": "stale_runner" | "exit_signal_recorded",
-    "message": "...",
-    "staleRunnerCheck": {
-      "ok": false,
-      "failures": ["stale runner: run X claimed N ms ago, last updated M ms ago (max age K ms)"]
-    }
-  }
-Exit codes:
-  0  Success / fresh runner / no owner record
-  1  Argument error or stale/exit-signal condition detected`.trim();
-const parseError = buildParseError(USAGE);
-function parseCliArgs(argv) {
-  const options = {
-    help: false,
-    repo: undefined,
-    pr: undefined,
-    staleRunnerMaxAgeMs: undefined,
-    runId: undefined,
-  };
-  const { tokens } = parseArgs({
-    args: [...argv],
-    options: {
-      help: { type: "boolean", short: "h" },
-      repo: { type: "string" },
-      pr: { type: "string" },
-      "stale-runner-max-age-ms": { type: "string" },
-      "run-id": { type: "string" },
-    },
-    allowPositionals: true,
-    strict: false,
-    tokens: true,
-  });
-  for (const token of tokens) {
-    if (token.kind === "positional") {
-      throw parseError(`Unknown argument: ${token.value}`);
-    }
-    if (token.kind !== "option") {
-      continue;
-    }
-    if (token.name === "help") {
-      options.help = true;
-      return options;
-    }
-    if (token.name === "repo") {
-      options.repo = requireTokenValue(token, parseError).trim();
-      continue;
-    }
-    if (token.name === "pr") {
-      options.pr = parsePrNumber(requireTokenValue(token, parseError), parseError);
-      continue;
-    }
-    if (token.name === "stale-runner-max-age-ms") {
-      const raw = requireTokenValue(token, parseError).trim();
-      const parsed = Number(raw);
-      if (!Number.isFinite(parsed) || parsed <= 0) {
-        throw parseError(`--stale-runner-max-age-ms must be a positive integer (ms), got: ${raw}`);
-      }
-      options.staleRunnerMaxAgeMs = Math.floor(parsed);
-      continue;
-    }
-    if (token.name === "run-id") {
-      options.runId = requireTokenValue(token, parseError).trim();
-      continue;
-    }
-    throw parseError(`Unknown argument: ${token.rawName}`);
-  }
-  if (options.repo === undefined || options.pr === undefined) {
-    throw parseError("detect-stale-runner requires both --repo <owner/name> and --pr <number>");
-  }
-  try {
-    parseRepoSlug(options.repo);
-  } catch (error) {
-    throw parseError(error instanceof Error ? error.message : String(error));
-  }
-  return options;
-}
-function resolveRunId(explicitRunId, env) {
-  if (typeof explicitRunId === "string" && explicitRunId.trim().length > 0) {
-    return explicitRunId.trim();
-  }
-  return resolveEnvRunId(env);
-}
-function buildStaleRunnerCheck(detection) {
-  if (detection.status === "no_owner_record") {
-    return {
-      ok: true,
-      failures: [],
-    };
-  }
-  if (detection.status === "exit_signal_recorded") {
-    return {
-      ok: false,
-      failures: [`exit signal recorded for run ${detection.activeRun?.runId ?? "unknown"}: refuse to merge`],
-    };
-  }
-  if (detection.status === "stale_runner") {
-    return {
-      ok: false,
-      failures: [
-        `stale runner: run ${detection.staleRunner.runId} claimed ${detection.staleRunner.claimedAgeMs}ms ago, last updated ${detection.staleRunner.updatedAgeMs}ms ago (max age ${detection.staleRunner.maxAgeMs}ms)`,
-      ],
-    };
-  }
-  return { ok: true, failures: [] };
-}
-export async function runDetectStaleRunner(options, { env = process.env, cwd = process.cwd() } = {}) {
-  const detection = await detectStaleRunner({
-    repo: options.repo,
-    pr: options.pr,
-    maxAgeMs: options.staleRunnerMaxAgeMs,
-    cwd,
-  });
-  const explicitRunId = resolveRunId(options.runId, env);
-  const ownershipLost = explicitRunId !== null
-    && detection.activeRun !== null
-    && detection.activeRun.runId !== explicitRunId;
-  const ownershipMissing = explicitRunId !== null && detection.activeRun === null;
-  const staleRunnerCheck = buildStaleRunnerCheck(detection);
-  if (ownershipMissing) {
-    return {
-      ok: false,
-      error: "ownership_lost",
-      repo: options.repo.trim().toLowerCase(),
-      pr: options.pr,
-      status: "ownership_lost",
-      activeRun: null,
-      runId: explicitRunId,
-      exitSignals: [],
-      filePath: detection.filePath,
-      maxAgeMs: detection.maxAgeMs,
-      message: `Stale-runner check: run ${explicitRunId} is no longer the active owner of ${options.repo}#${options.pr}; no active owner record exists.`,
-      staleRunnerCheck: {
-        ok: false,
-        failures: [`ownership_lost: no active owner record exists; run ${explicitRunId} is not the owner`],
-      },
-    };
-  }
-  if (ownershipLost) {
-    return {
-      ok: false,
-      error: "ownership_lost",
-      repo: options.repo.trim().toLowerCase(),
-      pr: options.pr,
-      status: "ownership_lost",
-      activeRun: detection.activeRun,
-      runId: explicitRunId,
-      exitSignals: detection.exitSignal?.signals ?? [],
-      filePath: detection.filePath,
-      maxAgeMs: detection.maxAgeMs,
-      message: `Stale-runner check: run ${explicitRunId} is no longer the active owner of ${options.repo}#${options.pr}; current owner is ${detection.activeRun?.runId}.`,
-      staleRunnerCheck: {
-        ok: false,
-        failures: [`ownership_lost: active owner is ${detection.activeRun?.runId ?? "unknown"}, not ${explicitRunId}`],
-      },
-    };
-  }
-  if (detection.status === "exit_signal_recorded") {
-    return {
-      ok: false,
-      error: STALE_RUNNER_ERROR.EXIT_SIGNAL_RECORDED,
-      repo: options.repo.trim().toLowerCase(),
-      pr: options.pr,
-      status: "exit_signal_recorded",
-      activeRun: detection.activeRun,
-      runId: explicitRunId,
-      exitSignals: detection.exitSignal?.signals ?? [],
-      filePath: detection.filePath,
-      maxAgeMs: detection.maxAgeMs,
-      message: detection.message,
-      staleRunnerCheck,
-    };
-  }
-  if (detection.status === "stale_runner") {
-    return {
-      ok: false,
-      error: STALE_RUNNER_ERROR.STALE_RUNNER,
-      repo: options.repo.trim().toLowerCase(),
-      pr: options.pr,
-      status: "stale_runner",
-      activeRun: detection.activeRun,
-      runId: explicitRunId,
-      exitSignals: [],
-      staleRunner: detection.staleRunner,
-      filePath: detection.filePath,
-      maxAgeMs: detection.maxAgeMs,
-      message: detection.message,
-      staleRunnerCheck,
-    };
-  }
-  return {
-    ok: true,
-    repo: options.repo.trim().toLowerCase(),
-    pr: options.pr,
-    status: detection.status,
-    activeRun: detection.activeRun,
-    runId: explicitRunId,
-    exitSignals: [],
-    filePath: detection.filePath,
-    maxAgeMs: detection.maxAgeMs,
-    staleRunnerCheck,
-  };
-}
-async function main() {
-  try {
-    const options = parseCliArgs(process.argv.slice(2));
-    if (options.help) {
-      console.log(USAGE);
-      return;
-    }
-    const result = await runDetectStaleRunner(options, { env: process.env });
-    if (!result.ok) {
-      console.error(JSON.stringify(result));
-      process.exitCode = 1;
-      return;
-    }
-    console.log(JSON.stringify(result));
-  } catch (error) {
-    const payload = formatCliError(error, { usage: USAGE });
-    console.error(JSON.stringify(payload));
-    process.exitCode = 1;
-  }
-}
-if (isDirectCliRun(import.meta.url)) {
-  await main();
-}

package/scripts/loop/pre-push-main-guard.mjs

@@ -1,117 +0,0 @@
-#!/usr/bin/env node
-import { createInterface } from "node:readline";
-import { buildParseError, formatCliError, isDirectCliRun } from "../_core-helpers.mjs";
-import { parseArgs } from "node:util";
-
-const DEVLOOPS_PREPUSH_BYPASS_VAR = "DEVLOOPS_PREPUSH_BYPASS";
-const BLOCKED_REFS = ["refs/heads/main"];
-
-const USAGE = `Usage:
-  pre-push-main-guard.mjs
-
-Reads pre-push hook input from stdin (Git pre-push hook protocol).
-Blocks direct pushes to protected refs (by default: refs/heads/main).
-
-Exit codes:
-  0  Push allowed (non-main ref, or bypassed)
-  1  Push blocked (target is a protected ref)
-
-Bypass:
-  DEVLOOPS_PREPUSH_BYPASS=1   Skip all checks (for emergencies only).
-                         Preferred: push a feature branch and open a PR.`.trim();
-
-const parseError = buildParseError(USAGE);
-
-/**
- * Parse pre-push hook input lines.
- *
- * Git pre-push hook protocol: each line is four whitespace-delimited fields:
- *   <local ref> <local sha> <remote ref> <remote sha>
- * The fourth field (remote sha) is all-zeros for new branches.
- *
- * This parser accepts lines with at least three fields (treating the
- * optional fourth field as null when absent). Malformed non-empty
- * lines with fewer than three fields are ignored silently — the guard
- * prefers to fail-open on unparseable input rather than silently
- * blocking unknown refs.
- */
-async function readPushRefs(input) {
-  const refs = [];
-  const rl = createInterface({ input, crlfDelay: Infinity });
-  for await (const line of rl) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    const parts = trimmed.split(/\s+/);
-    if (parts.length >= 3) {
-      refs.push({ localRef: parts[0], localSha: parts[1], remoteRef: parts[2], remoteSha: parts[3] || null });
-    }
-  }
-  return refs;
-}
-
-/**
- * Check whether any push target is a blocked ref.
- */
-function findBlockedRef(refs) {
-  for (const ref of refs) {
-    if (BLOCKED_REFS.includes(ref.remoteRef)) {
-      return ref.remoteRef;
-    }
-  }
-  return null;
-}
-
-export function parsePrePushGuardCliArgs(argv) {
-  const { tokens } = parseArgs({
-    args: [...argv],
-    options: {
-      help: { type: "boolean", short: "h" },
-    },
-    allowPositionals: true,
-    strict: false,
-    tokens: true,
-  });
-  for (const token of tokens) {
-    if (token.kind === "positional") {
-      throw parseError(`Unknown argument: ${token.value}`);
-    }
-    if (token.kind !== "option") {
-      continue;
-    }
-    if (token.name === "help") return { help: true };
-    throw parseError(`Unknown argument: ${token.rawName}`);
-  }
-  return { help: false };
-}
-
-export async function runCli(argv = process.argv.slice(2), { stdout = process.stdout, stderr = process.stderr, stdin = process.stdin, env = process.env } = {}) {
-  const options = parsePrePushGuardCliArgs(argv);
-  if (options.help) { stdout.write(`${USAGE}\n`); return { ok: true, help: true }; }
-
-  if ((env[DEVLOOPS_PREPUSH_BYPASS_VAR] ?? "").trim() === "1") {
-    stdout.write(JSON.stringify({ ok: true, bypassed: true, reason: `${DEVLOOPS_PREPUSH_BYPASS_VAR}=1` }) + "\n");
-    return { ok: true, bypassed: true };
-  }
-
-  const refs = await readPushRefs(stdin);
-  const blockedRef = findBlockedRef(refs);
-
-  if (blockedRef) {
-    const payload = {
-      ok: false,
-      error: "direct_push_to_main_blocked",
-      blockedRef,
-      message: "Direct pushes to main branch are blocked. Push a feature branch and open a pull request instead.",
-    };
-    stderr.write(`${JSON.stringify(payload)}\n`);
-    return payload;
-  }
-
-  const payload = { ok: true, blocked: false, refsChecked: refs.length };
-  stdout.write(`${JSON.stringify(payload)}\n`);
-  return payload;
-}
-
-if (isDirectCliRun(import.meta.url)) {
-  runCli().then((result) => { if (result?.ok === false) { process.exitCode = 1; } }).catch((error) => { process.stderr.write(`${formatCliError(error)}\n`); process.exitCode = 1; });
-}