package-registry-manager 0.22.6 → 0.22.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "package-registry-manager",
-  "version": "0.22.6",
+  "version": "0.22.7",
   "description": "Inspect repositories and guide secure package-registry setup",
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
     "provenance": true
   },
   "scripts": {
-    "syntax": "node --check src/cli.mjs && node --check src/direct-execution.mjs && node --check src/index.mjs && node --check src/browser.mjs && node --check src/browser-options.mjs && node --check src/browser-catalogue.mjs && node --check src/automation.mjs && node --check src/webdriver-automation.mjs && node --check src/profile.mjs && node --check src/setup.mjs && node --check src/auth-urls.mjs && node --check src/containers.mjs && node --check src/flows.mjs && node --check src/prerequisites.mjs && node --check src/registry-state.mjs && node --check src/workflows.mjs && node --check src/publishers.mjs && node --check src/skips.mjs && node --check src/tokens.mjs && node --check src/approvals.mjs && node --check src/default-browser.mjs && node --check src/pages.mjs && node --check src/crates-api.mjs && node --check src/sign-in-import.mjs && node --check scripts/publish-to-npm.mjs && node --check scripts/setup-npm.mjs && node --check scripts/sanitize-npm-userconfig.mjs && node --check src/python.mjs && node --check src/setup-batch.mjs && node --check src/workflow-proposal.mjs",
+    "syntax": "node --check src/cli.mjs && node --check src/direct-execution.mjs && node --check src/index.mjs && node --check src/browser.mjs && node --check src/browser-options.mjs && node --check src/browser-catalogue.mjs && node --check src/automation.mjs && node --check src/webdriver-automation.mjs && node --check src/profile.mjs && node --check src/setup.mjs && node --check src/auth-urls.mjs && node --check src/containers.mjs && node --check src/flows.mjs && node --check src/prerequisites.mjs && node --check src/registry-state.mjs && node --check src/workflows.mjs && node --check src/publishers.mjs && node --check src/skips.mjs && node --check src/tokens.mjs && node --check src/approvals.mjs && node --check src/default-browser.mjs && node --check src/pages.mjs && node --check src/crates-api.mjs && node --check src/sign-in-import.mjs && node --check scripts/publish-to-npm.mjs && node --check scripts/setup-npm.mjs && node --check scripts/sanitize-npm-userconfig.mjs && node --check src/python.mjs && node --check src/setup-batch.mjs && node --check src/workflow-proposal.mjs && node --check src/repository-identity.mjs && node --check src/repository-repair.mjs && node --check src/manifest-proposal.mjs",
     "lint": "eslint src test scripts --max-warnings 0",
     "lint:fix": "eslint src test scripts --fix --max-warnings 0",
     "format": "prettier --write .",
@@ -40,7 +40,7 @@
     "audit": "node scripts/npm-audit.mjs"
   },
   "dependencies": {
-    "browser-commander": "^0.26.2",
+    "browser-commander": "^0.26.3",
     "command-stream": "^2.0.0",
     "playwright": "^1.63.0",
     "selenium-webdriver": "^4.50.0"

package/src/discovery.mjs

@@ -4,6 +4,7 @@ import path from "node:path";
 import { CONTAINER_FILES, containerPackages } from "./containers.mjs";
 import { packageWorkflows, auditWrappers } from "./package-coverage.mjs";
 import { REGISTRIES } from "./model.mjs";
+import { inspectManifestRepositories } from "./repository-identity.mjs";
 import {
   TRUSTED_REGISTRIES,
   detectPublisher,
@@ -214,7 +215,7 @@ export async function inspectRepository(repository, options = {}) {
       left.manifest.localeCompare(right.manifest),
     );
   }
-  return inspection;
+  return inspectManifestRepositories(inspection);
 }
 
 /**

package/src/manifest-proposal.mjs

@@ -0,0 +1,201 @@
+import { mkdtemp, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { exec } from "command-stream";
+import {
+  githubSlug,
+  manifestUrls,
+  repositorySlug,
+} from "./repository-identity.mjs";
+
+function runner(options) {
+  return (
+    options.run ??
+    (async (program, args, cwd = options.repository) => {
+      const result = await exec(program, args, {
+        cwd,
+        env: process.env,
+        capture: true,
+        mirror: false,
+        stdin: "ignore",
+      });
+      if (result.code !== 0) {
+        throw new Error(
+          `${program} failed while preparing the manifest repository proposal`,
+        );
+      }
+      return String(result.stdout ?? "").trim();
+    })
+  );
+}
+
+function safeManifest(manifest) {
+  if (
+    !manifest ||
+    manifest
+      .split("/")
+      .some((part) => !part || part === "." || part === "..") ||
+    path.isAbsolute(manifest) ||
+    manifest.includes("\\")
+  ) {
+    throw new Error("unsafe manifest path for repository repair");
+  }
+}
+
+/** Change only stale repository values; preserve npm's repository.directory. */
+export function manifestRepositoryProposal(contents, manifest, slug) {
+  if (!githubSlug(slug)) {
+    throw new Error("invalid canonical repository");
+  }
+  const urls = manifestUrls(contents, manifest);
+  const stale = urls.filter(
+    (url) =>
+      githubSlug(url) && githubSlug(url).toLowerCase() !== slug.toLowerCase(),
+  );
+  if (!stale.length) {
+    return contents;
+  }
+  const url = `https://github.com/${slug}`;
+  if (manifest.endsWith("package.json")) {
+    const document = JSON.parse(contents.replace(/^\uFEFF/, ""));
+    if (typeof document.repository === "string") {
+      document.repository = url;
+    } else {
+      document.repository.url = `git+${url}.git`;
+    }
+    return `${JSON.stringify(document, null, 2)}\n`;
+  }
+  let proposal = contents;
+  for (const old of stale) {
+    proposal = proposal.replaceAll(old, old.replace(githubSlug(old), slug));
+  }
+  return proposal;
+}
+
+/** Check remote metadata before retrying; the original run may use an old SHA. */
+export async function verifyRemoteManifest(plan, options, reference) {
+  safeManifest(plan.package.manifest);
+  const run = runner(options);
+  const slug = repositorySlug(plan.repository);
+  const ref =
+    reference ??
+    (await run("gh", ["api", `repos/${slug}`, "--jq", ".default_branch"]));
+  if (!ref || ref.startsWith("-") || /[\s:]/.test(ref)) {
+    throw new Error("invalid remote manifest reference");
+  }
+  await run("git", ["fetch", "origin", ref]);
+  const contents = await run("git", [
+    "show",
+    `FETCH_HEAD:${plan.package.manifest}`,
+  ]);
+  return (
+    manifestRepositoryProposal(contents, plan.package.manifest, slug) ===
+    contents
+  );
+}
+
+/** Offer a reviewed branch and draft PR from the current remote default branch. */
+export async function offerManifestRepository(plan, options) {
+  const run = runner(options);
+  const slug = repositorySlug(plan.repository);
+  const manifest = plan.package.manifest;
+  safeManifest(manifest);
+  const remote = githubSlug(await run("git", ["remote", "get-url", "origin"]));
+  if (!remote) {
+    throw new Error(
+      "origin must be a GitHub repository for the manifest proposal",
+    );
+  }
+  const canonical = await run("gh", [
+    "api",
+    `repos/${remote}`,
+    "--jq",
+    ".full_name",
+  ]);
+  if (canonical.toLowerCase() !== slug.toLowerCase()) {
+    throw new Error("origin must resolve to the repository being repaired");
+  }
+  const base = await run("gh", [
+    "api",
+    `repos/${slug}`,
+    "--jq",
+    ".default_branch",
+  ]);
+  if (!base || base.startsWith("-") || /[\s:]/.test(base)) {
+    throw new Error("invalid default branch");
+  }
+  await run("git", ["fetch", "origin", base]);
+  const contents = await run("git", ["show", `FETCH_HEAD:${manifest}`]);
+  const proposal = manifestRepositoryProposal(contents, manifest, slug);
+  if (proposal === contents) {
+    return undefined;
+  }
+  console.log(`Proposed ${manifest}:\n${proposal}`);
+  if (
+    !options.yes &&
+    !/^y(?:es)?$/i.test(
+      await options.prompt(
+        "Create a branch and draft pull request with this repository URL fix? [y/N] ",
+      ),
+    )
+  ) {
+    return { status: "blocked" };
+  }
+  const branch = `prm/repository-url-${Date.now()}`;
+  const temporary = await mkdtemp(path.join(os.tmpdir(), "prm-manifest-"));
+  const checkout = path.join(temporary, "checkout");
+  let created = false;
+  try {
+    await run("git", ["worktree", "add", "-b", branch, checkout, "FETCH_HEAD"]);
+    created = true;
+    const target = path.join(checkout, manifest);
+    const root = await realpath(checkout);
+    const physical = await realpath(target);
+    if (
+      !physical.startsWith(`${root}${path.sep}`) ||
+      physical !== path.join(root, manifest)
+    ) {
+      throw new Error(
+        "manifest must stay inside the proposal worktree without symlinks",
+      );
+    }
+    const current = await readFile(target, "utf8");
+    const updated = manifestRepositoryProposal(current, manifest, slug);
+    await writeFile(target, updated);
+    await run("git", ["add", "--", manifest], checkout);
+    await run(
+      "git",
+      ["commit", "-m", "Fix manifest repository URL after repository transfer"],
+      checkout,
+    );
+    await run("git", ["push", "origin", `HEAD:refs/heads/${branch}`], checkout);
+    const url = await run(
+      "gh",
+      [
+        "pr",
+        "create",
+        "--repo",
+        slug,
+        "--base",
+        base,
+        "--head",
+        branch,
+        "--draft",
+        "--title",
+        "Fix manifest repository URL after repository transfer",
+        "--body",
+        `Update ${manifest} to name ${slug}. Review and merge this change, then re-run package-registry-manager setup to verify the repository metadata and retry the release.`,
+      ],
+      checkout,
+    );
+    console.log(
+      `Review and merge ${url}, then re-run setup. Release retries are paused.`,
+    );
+    return { status: "manifest-pr", url };
+  } finally {
+    if (created) {
+      await run("git", ["worktree", "remove", "--force", checkout]);
+    }
+    await rm(temporary, { recursive: true, force: true });
+  }
+}

package/src/plan.mjs

@@ -13,6 +13,7 @@ import { pagesSteps } from "./pages.mjs";
 import { planPrerequisites } from "./prerequisites.mjs";
 import { TRUSTED_REGISTRIES } from "./publishers.mjs";
 import { applyPython } from "./python.mjs";
+import { repairSteps } from "./repository-repair.mjs";
 
 const FLOWS = new Map([
   ["npm", npmFlow],
@@ -193,6 +194,14 @@ function flowPlan(inspection, packageInfo, options) {
     steps = [];
   } else if (mode === "attach") {
     steps = steps.filter((item) => !BOOTSTRAP_CONDITIONS.has(item.when));
+  } else if (mode === "repair") {
+    steps = repairSteps(
+      packageInfo,
+      context,
+      packageInfo.exists_on_registry !== true
+        ? steps
+        : steps.filter((item) => !BOOTSTRAP_CONDITIONS.has(item.when)),
+    );
   }
   if (options.ref) {
     const ref = bootstrapRef(options.ref);
@@ -239,10 +248,17 @@ function flowPlan(inspection, packageInfo, options) {
 
 /**
  * Chooses `bootstrap` for a package missing from its registry, `attach` for
- * one without trusted publishing, and `complete` when nothing is left to do.
+ * one without trusted publishing, `repair` for stale or unverified repository
+ * identities, and `complete` when nothing is left to do.
  * Unknown registry state leaves the mode unset.
  */
 export function planMode(packageInfo) {
+  if (
+    packageInfo.repository_mismatches?.length ||
+    packageInfo.publisher_settings_verified === false
+  ) {
+    return "repair";
+  }
   if (packageInfo.exists_on_registry === false) {
     return "bootstrap";
   }

package/src/registry-state.mjs

@@ -1,3 +1,13 @@
+import {
+  compareRepositories,
+  identityCommand,
+  inspectManifestRepositories,
+  provenanceRepositories,
+  publisherIdentities,
+  publisherMatches,
+  resolveRepository,
+} from "./repository-identity.mjs";
+
 /** Identifies the tool to registry APIs, as crates.io asks of clients. */
 export const USER_AGENT =
   "package-registry-manager (+https://github.com/link-foundation/package-registry-manager)";
@@ -63,6 +73,8 @@ export function npmName(name) {
  */
 export async function probeRegistryState(inspection, options = {}) {
   const probed = structuredClone(inspection);
+  await resolveRepository(probed, options);
+  await inspectManifestRepositories(probed);
   await Promise.all(
     probed.packages.map(async (packageInfo) => {
       if (!packageInfo.publishable) {
@@ -75,6 +87,46 @@ export async function probeRegistryState(inspection, options = {}) {
       if (state.trusted !== undefined) {
         packageInfo.trusted_publishing = state.trusted;
       }
+      const evidence = { ...packageInfo, ...state };
+      if (state.configured_publishers !== undefined) {
+        packageInfo.configured_publishers = state.configured_publishers;
+      }
+      if (state.provenance_repositories?.length) {
+        packageInfo.provenance_repositories = state.provenance_repositories;
+      }
+      if (packageInfo.registry === "npm" && state.exists) {
+        const output = await identityCommand(
+          "npm",
+          ["trust", "list", packageInfo.name, "--browser=false"],
+          { ...options, repository: inspection.repository.root },
+        );
+        if (output !== undefined) {
+          evidence.configured_publishers = publisherIdentities(output);
+          packageInfo.configured_publishers = evidence.configured_publishers;
+        }
+      }
+      compareRepositories(packageInfo, probed.repository, evidence);
+      if (
+        state.trusted &&
+        ["npm", "crates-io", "pypi"].includes(packageInfo.registry)
+      ) {
+        const expected = {
+          organization: probed.repository.github_owner,
+          repository: probed.repository.github_repository,
+          workflow: packageInfo.workflow,
+          environment: packageInfo.environment,
+        };
+        packageInfo.publisher_settings_verified = Boolean(
+          evidence.configured_publishers?.some((publisher) =>
+            publisherMatches(publisher, expected),
+          ),
+        );
+        if (!packageInfo.publisher_settings_verified) {
+          (packageInfo.warnings ??= []).push(
+            "configured trusted publisher could not be verified; setup must check the repository, workflow and environment in registry settings",
+          );
+        }
+      }
     }),
   );
   return probed;
@@ -100,21 +152,47 @@ export async function probePackage(packageInfo, options = {}) {
       : { exists: false, trusted: false };
   }
   switch (packageInfo.registry) {
-    case "npm":
+    case "npm": {
+      const attestations = document.dist?.attestations?.url;
+      const provenance = attestations
+        ? await getJson(attestations, options)
+        : undefined;
+      const sources = provenanceRepositories(provenance);
       return {
         exists: true,
         trusted: Boolean(document._npmUser?.trustedPublisher),
         version: document.version,
+        ...(sources.length ? { provenance_repositories: sources } : {}),
       };
-    case "crates-io":
+    }
+    case "crates-io": {
+      const latest =
+        (document.versions ?? []).find(
+          (item) => item.num === document.crate?.max_version,
+        ) ?? document.versions?.[0];
+      const settings = await getJson(
+        `${registryEndpoint("crates-io", env)}/trusted_publishing/github_configs?crate=${encodeURIComponent(packageInfo.name)}`,
+        options,
+      );
       return {
         exists: true,
-        trusted: (document.versions ?? []).some((item) =>
-          Boolean(item.trustpub_data),
+        trusted: Boolean(latest?.trustpub_data),
+        provenance_repositories: publisherIdentities(latest?.trustpub_data).map(
+          (publisher) => publisher.repository,
         ),
+        ...(Array.isArray(settings?.github_configs) && !settings.meta?.next_page
+          ? { configured_publishers: publisherIdentities(settings) }
+          : {}),
       };
-    case "pypi":
-      return { exists: true, trusted: await pypiProvenance(document, options) };
+    }
+    case "pypi": {
+      const provenance = await pypiProvenance(document, options);
+      return {
+        exists: true,
+        trusted: Boolean(provenance),
+        provenance_repositories: provenanceRepositories(provenance),
+      };
+    }
     default:
       return { exists: true };
   }
@@ -128,7 +206,7 @@ async function pypiProvenance(document, options) {
   }
   const base = registryEndpoint("pypi", options.env ?? process.env);
   const url = `${base}/integrity/${encodeURIComponent(document.info.name)}/${encodeURIComponent(version)}/${encodeURIComponent(file)}/provenance`;
-  return Boolean(await getJson(url, options));
+  return getJson(url, options);
 }
 
 /**

package/src/repository-identity.mjs

@@ -0,0 +1,317 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { ANSI } from "./auth-urls.mjs";
+
+const execute = promisify(execFile);
+const SLUG = /^[a-z\d_.-]+\/[a-z\d_.-]+$/i;
+
+/** Normalize GitHub HTTPS, SSH, npm shorthand and provenance source URLs. */
+export function githubSlug(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  let text = value
+    .trim()
+    .replace(/^git\+/, "")
+    .replace(/^github:/, "");
+  text = text
+    .replace(/^git@github\.com:/, "https://github.com/")
+    .replace(/^ssh:\/\/git@github\.com\//, "https://github.com/");
+  if (text.startsWith("https://github.com/")) {
+    text = text
+      .slice(19)
+      .split(/[?#]/)[0]
+      .split("/")
+      .slice(0, 2)
+      .join("/")
+      .split("@")[0];
+  }
+  text = text.replace(/\.git\/?$/, "");
+  return SLUG.test(text) ? text : null;
+}
+
+export function repositorySlug(repository) {
+  return repository.github_owner && repository.github_repository
+    ? `${repository.github_owner}/${repository.github_repository}`
+    : null;
+}
+
+/** Read only declared repository metadata, preserving all PyPI source URLs. */
+export function manifestUrls(contents, manifest) {
+  contents = contents.replace(/^\uFEFF/, "");
+  if (manifest.endsWith("package.json")) {
+    let metadata;
+    try {
+      metadata = JSON.parse(contents).repository;
+    } catch {
+      return [];
+    }
+    return [typeof metadata === "string" ? metadata : metadata?.url].filter(
+      Boolean,
+    );
+  }
+  let table = "";
+  let inlineUrls = null;
+  const urls = [];
+  for (const line of contents.split(/\r?\n/)) {
+    const header = /^\s*\[([^\]]+)\]/.exec(line);
+    if (header) {
+      table = header[1].trim();
+    }
+    if (
+      ["project", "tool.poetry"].includes(table) &&
+      /^\s*urls\s*=\s*\{/.test(line)
+    ) {
+      inlineUrls = line.slice(line.indexOf("{") + 1);
+    } else if (inlineUrls !== null) {
+      inlineUrls += `\n${line}`;
+    }
+    if (inlineUrls?.includes("}")) {
+      for (const field of inlineUrls
+        .slice(0, inlineUrls.indexOf("}"))
+        .matchAll(/(?:[\w-]+|"[^"]+"|'[^']+')\s*=\s*(["'])(.*?)\1/g)) {
+        urls.push(field[2]);
+      }
+      inlineUrls = null;
+    }
+    const field =
+      /^\s*([\w-]+|"[^"]+"|'[^']+')\s*=\s*(["'])(.*?)\2\s*(?:#.*)?$/.exec(line);
+    if (!field) {
+      continue;
+    }
+    const key = field[1].replaceAll(/["']/g, "").toLowerCase();
+    if (
+      (table === "package" || table === "tool.poetry") &&
+      key === "repository"
+    ) {
+      urls.push(field[3]);
+    }
+    if (["project.urls", "tool.poetry.urls"].includes(table)) {
+      urls.push(field[3]);
+    }
+  }
+  return urls;
+}
+
+/** Findings name the evidence source; provenance is never treated as configuration. */
+export function compareRepositories(packageInfo, repository, evidence = {}) {
+  const slug = repositorySlug(repository);
+  if (!slug) {
+    return packageInfo;
+  }
+  const pairs = [
+    ...(evidence.manifest_urls ?? []).map((url) => [
+      "manifest",
+      githubSlug(url),
+    ]),
+    ...(evidence.provenance_repositories ?? []).map((url) => [
+      "provenance",
+      githubSlug(url),
+    ]),
+    ...(evidence.configured_publishers ?? []).map((publisher) => [
+      "trusted publisher",
+      publisher.repository,
+    ]),
+  ];
+  const findings = pairs
+    .filter(([, old]) => old && old.toLowerCase() !== slug.toLowerCase())
+    .map(([source, old]) => ({ source, repository: old }));
+  packageInfo.repository_mismatches = [
+    ...new Map(
+      findings.map((finding) => [
+        `${finding.source}:${finding.repository.toLowerCase()}`,
+        finding,
+      ]),
+    ).values(),
+  ];
+  if (!packageInfo.repository_mismatches.length) {
+    delete packageInfo.repository_mismatches;
+  }
+  const warnings = (packageInfo.warnings ?? []).filter(
+    (warning) => !warning.startsWith("repository mismatch:"),
+  );
+  for (const finding of packageInfo.repository_mismatches ?? []) {
+    warnings.push(
+      `repository mismatch: ${finding.source} still names ${finding.repository}; repository being set up is ${slug}`,
+    );
+  }
+  if (warnings.length) {
+    packageInfo.warnings = warnings;
+  } else {
+    delete packageInfo.warnings;
+  }
+  return packageInfo;
+}
+
+/** Inspect local metadata even offline; retain URLs only when a fix is needed. */
+export async function inspectManifestRepositories(inspection) {
+  for (const packageInfo of inspection.packages) {
+    if (!["npm", "crates-io", "pypi"].includes(packageInfo.registry)) {
+      continue;
+    }
+    const contents = await readFile(
+      path.join(inspection.repository.root, packageInfo.manifest),
+      "utf8",
+    ).catch(() => null);
+    if (contents === null) {
+      continue;
+    }
+    const urls = manifestUrls(contents, packageInfo.manifest);
+    compareRepositories(packageInfo, inspection.repository, {
+      ...packageInfo,
+      manifest_urls: urls,
+    });
+    if (
+      packageInfo.repository_mismatches?.some(
+        (finding) => finding.source === "manifest",
+      )
+    ) {
+      packageInfo.manifest_urls = urls;
+    }
+  }
+  return inspection;
+}
+
+/** Run read-only identity queries without opening a browser or exposing auth output. */
+export async function identityCommand(program, args, options = {}) {
+  if (options.runIdentity) {
+    return options.runIdentity(program, args);
+  }
+  try {
+    const { stdout } = await execute(program, args, {
+      cwd: options.repository,
+      timeout: 10_000,
+      maxBuffer: 2 * 1024 * 1024,
+      env: options.env ?? process.env,
+    });
+    return stdout;
+  } catch {
+    if (options.verbose) {
+      console.error(`${program} repository identity lookup unavailable`);
+    }
+    return undefined;
+  }
+}
+
+/** Resolve redirects through GitHub's canonical full_name before comparison. */
+export async function resolveRepository(inspection, options = {}) {
+  const slug = repositorySlug(inspection.repository);
+  if (!slug) {
+    return;
+  }
+  const output = await identityCommand(
+    "gh",
+    ["api", `repos/${slug}`, "--jq", ".full_name"],
+    options,
+  );
+  const canonical = githubSlug(output);
+  if (canonical) {
+    [
+      inspection.repository.github_owner,
+      inspection.repository.github_repository,
+    ] = canonical.split("/");
+  }
+}
+
+/** Convert npm JSON/human output and crates.io/PyPI settings to public identities. */
+export function publisherIdentities(document) {
+  if (typeof document === "string") {
+    try {
+      return publisherIdentities(JSON.parse(document));
+    } catch {
+      document = document.replaceAll(ANSI, "");
+      const blocks = document
+        .split(/(?=^\s*type:)/m)
+        .filter((block) => /^\s*type:/m.test(block));
+      if (blocks.length > 1) {
+        return blocks.flatMap(publisherIdentities);
+      }
+      const values = {};
+      for (const line of document.replaceAll(ANSI, "").split(/\r?\n/)) {
+        const field =
+          /^\s*(id|type|repository|file|environment):\s*(\S.*)$/.exec(line);
+        if (field) {
+          values[field[1]] = field[2].trim();
+        }
+      }
+      return publisherIdentities(values);
+    }
+  }
+  if (Array.isArray(document)) {
+    return document.flatMap(publisherIdentities);
+  }
+  if (!document || typeof document !== "object") {
+    return [];
+  }
+  if (document.type && document.type !== "github") {
+    return [];
+  }
+  for (const key of ["github_configs", "publishers", "trustedPublishers"]) {
+    if (Array.isArray(document[key])) {
+      return publisherIdentities(document[key]);
+    }
+  }
+  const repository = githubSlug(
+    document.claims?.repository ??
+      document.repository ??
+      (document.repository_owner && document.repository_name
+        ? `${document.repository_owner}/${document.repository_name}`
+        : null),
+  );
+  if (!repository) {
+    return [];
+  }
+  return [
+    {
+      ...(document.id !== undefined ? { id: String(document.id) } : {}),
+      repository,
+      workflow:
+        document.claims?.workflow_ref?.file ??
+        document.workflow_filename ??
+        document.workflow ??
+        document.file ??
+        null,
+      environment: document.claims?.environment ?? document.environment ?? null,
+    },
+  ];
+}
+
+export function publisherMatches(publisher, expected) {
+  return (
+    publisher.repository.toLowerCase() ===
+      `${expected.organization}/${expected.repository}`.toLowerCase() &&
+    publisher.workflow === expected.workflow &&
+    (publisher.environment ?? null) === (expected.environment ?? null)
+  );
+}
+
+/** Extract source identity from npm SLSA envelopes and PyPI publisher bundles. */
+export function provenanceRepositories(document) {
+  const urls = [];
+  for (const bundle of document?.attestation_bundles ?? []) {
+    if (bundle.publisher?.kind === "GitHub") {
+      urls.push(bundle.publisher.repository);
+    }
+  }
+  for (const attestation of document?.attestations ?? []) {
+    const payload = attestation.bundle?.dsseEnvelope?.payload;
+    if (typeof payload !== "string" || payload.length > 2 * 1024 * 1024) {
+      continue;
+    }
+    try {
+      const statement = JSON.parse(
+        Buffer.from(payload, "base64").toString("utf8"),
+      );
+      const predicate = statement.predicate;
+      urls.push(
+        predicate?.invocation?.configSource?.uri,
+        predicate?.buildDefinition?.externalParameters?.workflow?.repository,
+      );
+    } catch {
+      /* Malformed provenance leaves source identity unknown. */
+    }
+  }
+  return [...new Set(urls.map(githubSlug).filter(Boolean))];
+}

package/src/repository-repair.mjs

@@ -0,0 +1,375 @@
+import { pageFetchScript } from "./crates-api.mjs";
+import {
+  publisherIdentities,
+  publisherMatches,
+  repositorySlug,
+} from "./repository-identity.mjs";
+import { offerManifestRepository } from "./manifest-proposal.mjs";
+
+/** Insert transfer repairs before any release retry or secret cleanup. */
+export function repairSteps(packageInfo, context, steps) {
+  const ids = new Set(["verify-trusted-publisher", "rerun-release"]);
+  const result = steps.filter((step) => !ids.has(step.id));
+  if (
+    packageInfo.registry !== "npm" &&
+    !context.manual &&
+    packageInfo.exists_on_registry === true
+  ) {
+    const before = result.findIndex((step) =>
+      ["configure-trusted-publisher", "attach-trusted-publisher"].includes(
+        step.id,
+      ),
+    );
+    result.splice(Math.max(0, before), 0, {
+      id: "check-repository-publisher",
+      title: "Read the current repository's configured publisher",
+      kind: "check",
+      description:
+        "Check the repository, workflow and environment in authenticated settings before attaching a replacement.",
+    });
+  }
+  const repairs = [
+    {
+      id: "verify-repository-publisher",
+      title: "Verify the new repository's trusted publisher",
+      kind: "check",
+      description:
+        "Read registry settings and require the new repository, workflow and environment before removing old trust.",
+    },
+    {
+      id: "remove-old-publisher",
+      title: "Remove the old repository's trusted publisher",
+      kind: "api",
+      description:
+        "Remove only publishers naming the old repository, after verifying the replacement; confirm their removal in registry settings.",
+      confirm: true,
+    },
+  ];
+  if (
+    packageInfo.repository_mismatches?.some(
+      (finding) => finding.source === "manifest",
+    )
+  ) {
+    repairs.push({
+      id: "fix-manifest-repository",
+      title: "Offer the manifest repository URL fix in a reviewed pull request",
+      kind: "api",
+      description:
+        "Create a branch and draft pull request for the repository URL. Pause release retries until it is merged.",
+      confirm: true,
+    });
+  }
+  repairs.push({
+    id: "rerun-release",
+    title: "Re-run failed release jobs after repository repairs",
+    kind: "check",
+    description:
+      "Verify the remote default-branch manifests name the current repository before retrying failed release jobs.",
+  });
+  if (packageInfo.exists_on_registry !== true) {
+    const manifestFix = repairs.find(
+      (step) => step.id === "fix-manifest-repository",
+    );
+    if (manifestFix) {
+      result.unshift(manifestFix);
+      repairs.splice(repairs.indexOf(manifestFix), 1);
+    }
+  }
+  const insertion = result.findLastIndex((step) =>
+    ["configure-trusted-publisher", "attach-trusted-publisher"].includes(
+      step.id,
+    ),
+  );
+  result.splice(insertion + 1, 0, ...repairs);
+  return result;
+}
+
+async function npmPublishers(session) {
+  const step = session.plan.steps.find((item) => item.id === "check-trust");
+  const result = await session.runProcess(step, false);
+  if (result.code !== 0) {
+    throw new Error(
+      "could not read npm trusted publishers; repository repair stopped",
+    );
+  }
+  return publisherIdentities(result.stdout);
+}
+
+async function cratesPublishers(session) {
+  const page = await session.automatedPage();
+  const publishers = [];
+  let query = `?crate=${encodeURIComponent(session.plan.package.name)}`;
+  const seen = new Set();
+  while (query) {
+    if (!query.startsWith("?") || seen.has(query)) {
+      throw new Error("invalid crates.io publisher pagination");
+    }
+    seen.add(query);
+    const response = await page.evaluate(
+      pageFetchScript(
+        "GET",
+        `/api/v1/trusted_publishing/github_configs${query}`,
+      ),
+    );
+    if (
+      response.status !== 200 ||
+      !Array.isArray(response.body?.github_configs)
+    ) {
+      throw new Error("could not read crates.io trusted publishers");
+    }
+    publishers.push(...publisherIdentities(response.body));
+    query = response.body.meta?.next_page;
+  }
+  return publishers;
+}
+
+/** PyPI exposes configured publishers only in the authenticated settings page. */
+export const PYPI_PUBLISHERS_SCRIPT = `(() => [...document.querySelectorAll(".table--publisher-list tbody tr")].flatMap(row => {
+  const details = row.querySelector("small");
+  const link = details?.querySelector('a[href^="https://github.com/"]');
+  const remove = row.querySelector('a[href^="#remove-publisher-"]');
+  if (!link || !remove) return [];
+  const field = label => {
+    const heading = [...details.querySelectorAll("b")].find(item => item.textContent.trim() === label);
+    if (!heading) return undefined;
+    let value = "";
+    for (let node = heading.nextSibling; node && node.nodeName !== "BR"; node = node.nextSibling) {
+      if (node.nodeName === "I") return null;
+      value += node.textContent;
+    }
+    return value.trim() || null;
+  };
+  const workflow = field("Workflow:");
+  const environment = field("Environment name:");
+  if (!workflow || environment === undefined) return [];
+  return [{ id: remove.getAttribute("href").slice(18), repository: link.href, workflow, environment }];
+}))()`;
+
+/** Submit the site's existing removal form, retaining its hidden CSRF fields. */
+export function pypiRemovalScript(id) {
+  return `(async () => {
+    const input = [...document.querySelectorAll('input[name="publisher_id"]')].find(input => input.value === ${JSON.stringify(id)});
+    const form = input?.closest("form");
+    if (!form || form.method.toLowerCase() !== "post" || form.action !== location.href.split("?")[0]) throw new Error("PyPI publisher removal form unavailable");
+    const response = await fetch(form.action, { method: "POST", body: new FormData(form), credentials: "same-origin" });
+    return { status: response.status };
+  })()`;
+}
+
+async function pypiPublishers(session) {
+  const url = `https://pypi.org/manage/project/${encodeURIComponent(session.plan.package.name)}/settings/publishing/`;
+  await session.open(url, true);
+  await session.prompt(
+    "Sign in and show the project's trusted publishers, then press Enter...",
+  );
+  const rows = await session.automation?.evaluate(PYPI_PUBLISHERS_SCRIPT);
+  if (!Array.isArray(rows)) {
+    throw new Error("could not read PyPI trusted publishers");
+  }
+  return publisherIdentities(rows);
+}
+
+async function configuredPublishers(session) {
+  switch (session.plan.registry) {
+    case "npm":
+      return npmPublishers(session);
+    case "crates-io":
+      return cratesPublishers(session);
+    default:
+      return pypiPublishers(session);
+  }
+}
+
+async function verifyPublisher(session) {
+  const publishers = await configuredPublishers(session);
+  if (
+    !publishers.some((publisher) =>
+      publisherMatches(publisher, session.plan.trusted_publisher),
+    )
+  ) {
+    throw new Error(
+      "registry settings do not list the new repository's workflow and environment; old publishers were kept",
+    );
+  }
+  session.repositoryPublishers = publishers;
+  session.conditions.add("repository-publisher-verified");
+  session.conditions.delete("trust-missing");
+  return publishers;
+}
+
+async function removeOldPublishers(session) {
+  if (!session.conditions.has("repository-publisher-verified")) {
+    throw new Error(
+      "verify the replacement publisher before removing old trust",
+    );
+  }
+  const publishers = await verifyPublisher(session);
+  const current = repositorySlug(session.plan.repository).toLowerCase();
+  const old = new Set(
+    publishers
+      .filter((publisher) => publisher.repository.toLowerCase() !== current)
+      .map((publisher) => publisher.repository.toLowerCase()),
+  );
+  for (const publisher of publishers.filter((item) =>
+    old.has(item.repository.toLowerCase()),
+  )) {
+    if (!publisher.id || !/^[\w-]+$/.test(publisher.id)) {
+      throw new Error("the old publisher has no usable registry identifier");
+    }
+    if (
+      !session.options.yes &&
+      !/^y(?:es)?$/i.test(
+        await session.prompt(
+          `Remove trusted publisher ${publisher.repository} (${publisher.workflow})? [y/N] `,
+        ),
+      )
+    ) {
+      throw new Error("old publisher removal declined; release retry stopped");
+    }
+    if (session.plan.registry === "npm") {
+      const command = session.plan.steps.find(
+        (step) => step.id === "check-trust",
+      ).command;
+      const args = [...command.args];
+      args[args.indexOf("list")] = "revoke";
+      args.push("--id", publisher.id, "--yes");
+      const result = await session.runProcess(
+        { command: { program: command.program, args } },
+        true,
+      );
+      if (result.code !== 0) {
+        throw new Error("npm did not revoke the old publisher");
+      }
+    } else if (session.plan.registry === "crates-io") {
+      const page = await session.automatedPage();
+      const result = await page.evaluate(
+        pageFetchScript(
+          "DELETE",
+          `/api/v1/trusted_publishing/github_configs/${publisher.id}`,
+        ),
+      );
+      if (result.status < 200 || result.status >= 300) {
+        throw new Error("crates.io did not remove the old publisher");
+      }
+    } else {
+      const result = await session.automation.evaluate(
+        pypiRemovalScript(publisher.id),
+      );
+      if (result.status < 200 || result.status >= 300) {
+        throw new Error("PyPI did not remove the old publisher");
+      }
+    }
+  }
+  if (
+    (await verifyPublisher(session)).some((publisher) =>
+      old.has(publisher.repository.toLowerCase()),
+    )
+  ) {
+    throw new Error(
+      "the old repository still has a trusted publisher; release retry stopped",
+    );
+  }
+}
+
+/** Execute repairs; a manifest PR pauses setup for review and merge. */
+export async function runRepositoryRepair(session, step) {
+  if (step.id === "check-repository-publisher") {
+    const matches = (await configuredPublishers(session)).some((publisher) =>
+      publisherMatches(publisher, session.plan.trusted_publisher),
+    );
+    if (matches) {
+      session.conditions.delete("trust-missing");
+    } else {
+      session.conditions.add("trust-missing");
+    }
+    return;
+  }
+  if (step.id === "verify-repository-publisher") {
+    return verifyPublisher(session);
+  }
+  if (step.id === "remove-old-publisher") {
+    return removeOldPublishers(session);
+  }
+  if (step.id === "fix-manifest-repository") {
+    const result = await offerManifestRepository(session.plan, {
+      ...session.options,
+      prompt: (message) => session.prompt(message),
+    });
+    if (result) {
+      session.outcome = result;
+    }
+    return;
+  }
+  // A failed historical run checks out its original SHA. Require its manifests
+  // to match, or dispatch a fresh run from the corrected default branch.
+  if (!session.conditions.has("repository-publisher-verified")) {
+    throw new Error("verify repository repairs before retrying release jobs");
+  }
+  const expected = repositorySlug(session.plan.repository);
+  const result = await session.capture({
+    command: {
+      program: "gh",
+      args: [
+        "run",
+        "list",
+        "--repo",
+        expected,
+        "--workflow",
+        session.plan.trusted_publisher.workflow,
+        "--limit",
+        "1",
+        "--json",
+        "databaseId,conclusion,headSha",
+      ],
+    },
+    cwd: ".",
+  });
+  if (result.code !== 0) {
+    throw new Error("could not inspect release jobs after repository repair");
+  }
+  const [run] = JSON.parse(result.stdout || "[]");
+  if (run?.conclusion !== "failure") {
+    return;
+  }
+  const { verifyRemoteManifest } = await import("./manifest-proposal.mjs");
+  const corrected =
+    Boolean(run.headSha) &&
+    (await verifyRemoteManifest(session.plan, session.options, run.headSha));
+  if (
+    !corrected &&
+    !(await verifyRemoteManifest(session.plan, session.options))
+  ) {
+    throw new Error(
+      "merge the manifest repository URL fix before retrying release jobs",
+    );
+  }
+  const command = corrected
+    ? {
+        program: "gh",
+        args: [
+          "run",
+          "rerun",
+          String(run.databaseId),
+          "--repo",
+          expected,
+          "--failed",
+        ],
+      }
+    : {
+        program: "gh",
+        args: [
+          "workflow",
+          "run",
+          session.plan.trusted_publisher.workflow,
+          "--repo",
+          expected,
+        ],
+      };
+  await session.command({
+    ...step,
+    kind: "command",
+    command,
+    cwd: ".",
+    confirm: true,
+  });
+}

package/src/setup-batch.mjs

@@ -108,6 +108,7 @@ export async function executePlans(plans, options, summary = true) {
           registry: plan.registry,
           package: plan.package.name,
           status: plan.steps.length === 0 ? "complete" : "configured",
+          ...session.outcome,
         });
         if (plan.trusted_publisher?.workflow) {
           console.log(`\n${oidcReleaseNote(plan.trusted_publisher.workflow)}`);

package/src/setup.mjs

@@ -33,6 +33,11 @@ import { packageDirectory } from "./plan.mjs";
 import { twoFactorMode } from "./prerequisites.mjs";
 import { getJson, probePackage } from "./registry-state.mjs";
 import { launchBrowser, signInDomains } from "./sign-in-import.mjs";
+import { runRepositoryRepair } from "./repository-repair.mjs";
+import {
+  publisherIdentities,
+  publisherMatches,
+} from "./repository-identity.mjs";
 import { reportTokenSecrets, verifyTokenRevoked } from "./tokens.mjs";
 
 export { defaultBrowserProfile } from "./profile.mjs";
@@ -64,7 +69,7 @@ export class SetupSession {
     if (plan.package.exists_on_registry === false) {
       this.conditions.add("package-missing");
     }
-    if (plan.package.trusted_publishing !== true) {
+    if (plan.package.trusted_publishing !== true || plan.mode === "repair") {
       this.conditions.add("trust-missing");
     }
     this.values = {};
@@ -80,6 +85,9 @@ export class SetupSession {
       } else if (!step.when || this.conditions.has(step.when)) {
         this.log(`==> ${step.title}`);
         await this.runStep(step);
+        if (this.outcome) {
+          break;
+        }
       } else if (this.options.verbose) {
         console.error(`skip ${step.id}: condition ${step.when} does not hold`);
       }
@@ -148,6 +156,17 @@ export class SetupSession {
   }
 
   async runStep(step) {
+    if (
+      [
+        "check-repository-publisher",
+        "verify-repository-publisher",
+        "remove-old-publisher",
+        "fix-manifest-repository",
+      ].includes(step.id) ||
+      (step.id === "rerun-release" && this.plan.mode === "repair")
+    ) {
+      return runRepositoryRepair(this, step);
+    }
     switch (step.kind) {
       case "check":
         if (step.id === "check-name-policy") {
@@ -206,7 +225,7 @@ export class SetupSession {
       );
     }
     toggle(this.conditions, "package-missing", !state.exists);
-    if (state.trusted === true) {
+    if (state.trusted === true && this.plan.mode !== "repair") {
       this.conditions.delete("trust-missing");
     }
     this.values.previous_version = state.version;
@@ -236,7 +255,13 @@ export class SetupSession {
         return;
       case "check-trust":
       case "verify-trusted-publisher": {
-        const trusted = result.code === 0 && listsTrustedPublisher(output);
+        const trusted =
+          result.code === 0 &&
+          (this.plan.mode === "repair"
+            ? publisherIdentities(output).some((publisher) =>
+                publisherMatches(publisher, this.plan.trusted_publisher),
+              )
+            : listsTrustedPublisher(output));
         toggle(this.conditions, "trust-missing", !trusted);
         if (step.id === "verify-trusted-publisher" && !trusted) {
           throw new Error(
@@ -717,6 +742,7 @@ export class SetupSession {
     const { command, cwd } = this.prepare(step);
     const result = await exec(command.program, command.args, {
       cwd,
+      env: process.env,
       capture: true,
       mirror: this.options.verbose,
       stdin: "ignore",