@mnaoumov/typescript-dev-toolkit 3.2.0 → 3.4.0

package/dist/lib/cjs/upstream-sync.cjs

@@ -0,0 +1,294 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var upstream_sync_exports = {};
+__export(upstream_sync_exports, {
+  buildPrBody: () => buildPrBody,
+  compareWithUpstream: () => compareWithUpstream,
+  parseUpstreamsConfig: () => parseUpstreamsConfig,
+  planSync: () => planSync,
+  syncUpstreams: () => syncUpstreams,
+  writePin: () => writePin
+});
+module.exports = __toCommonJS(upstream_sync_exports);
+var import_node_fs = require('node:fs');
+var import_node_path = require('node:path');
+const COMPARE_FILE_LIMIT = 300;
+const SHORT_SHA_LENGTH = 12;
+const OUTPUT_TAIL_LINES = 60;
+const JSON_INDENT_SPACES = 2;
+function buildPrBody(plan, steps, diffStat) {
+  const { entry, head, pin } = plan.status;
+  const source = isGitUpstream(entry) ? `\`${entry.repo}@${entry.ref}\`` : `npm \`${entry.npm}@${entry.tag ?? "latest"}\``;
+  const lines = [
+    `Upstream \`${entry.name}\` moved: ${source} from \`${pin}\` to \`${head}\`.`,
+    "",
+    `Compare: ${plan.status.compareUrl}`,
+    ""
+  ];
+  if (isGitUpstream(entry)) {
+    lines.push("### Changed upstream files", "", ...plan.status.changedPaths.map((path) => `- \`${path}\``));
+    if (plan.status.truncated) {
+      lines.push(`- GitHub lists at most ${String(COMPARE_FILE_LIMIT)} files: open the compare link for the rest.`);
+    }
+    lines.push("");
+  }
+  if (steps === null) {
+    lines.push("### Handler", "", `\`${entry.handler}\`: not run (dry run).`, "");
+  } else {
+    lines.push(...describeStep("Handler", steps.handler));
+    if (steps.verify !== null) {
+      lines.push(...describeStep("Verify", steps.verify));
+    }
+  }
+  if (diffStat !== null) {
+    lines.push("### Generated changes", "", "```text", diffStat.trimEnd(), "```", "");
+  }
+  lines.push("This PR was opened by the upstream-sync job and is never merged automatically.");
+  return `${lines.join("\n")}
+`;
+}
+async function compareWithUpstream(entry, dependencies) {
+  if (!isGitUpstream(entry)) {
+    const tag = entry.tag ?? "latest";
+    const packument = await dependencies.fetchJson(`https://registry.npmjs.org/${entry.npm.replace("/", "%2f")}`);
+    const head2 = packument["dist-tags"][tag];
+    if (head2 === void 0) {
+      throw new Error(`npm package ${entry.npm} has no dist-tag "${tag}".`);
+    }
+    return {
+      changedPaths: [],
+      compareUrl: `https://www.npmjs.com/package/${entry.npm}/v/${head2}`,
+      entry,
+      head: head2,
+      pin: entry.version,
+      state: head2 === entry.version ? "current" : "moved",
+      truncated: false
+    };
+  }
+  const commit = await dependencies.fetchJson(`https://api.github.com/repos/${entry.repo}/commits/${encodeURIComponent(entry.ref)}`);
+  const head = commit.sha;
+  const compareUrl = `https://github.com/${entry.repo}/compare/${entry.commit}...${head}`;
+  if (head === entry.commit) {
+    return { changedPaths: [], compareUrl, entry, head, pin: entry.commit, state: "current", truncated: false };
+  }
+  const compare = await dependencies.fetchJson(`https://api.github.com/repos/${entry.repo}/compare/${entry.commit}...${head}`);
+  const files = compare.files ?? [];
+  const touched = new Set(files.flatMap((file) => file.previous_filename === void 0 ? [file.filename] : [file.filename, file.previous_filename]));
+  const changedPaths = [...touched].filter((path) => entry.paths.some((glob) => (0, import_node_path.matchesGlob)(path, glob))).sort();
+  const isTruncated = files.length >= COMPARE_FILE_LIMIT;
+  return {
+    changedPaths,
+    compareUrl,
+    entry,
+    head,
+    pin: entry.commit,
+    state: changedPaths.length > 0 || isTruncated ? "moved" : "unwatched",
+    truncated: isTruncated
+  };
+}
+function parseUpstreamsConfig(text) {
+  const config = JSON.parse(text);
+  if (!Array.isArray(config.upstreams)) {
+    throw new TypeError('upstreams.json has no "upstreams" array.');
+  }
+  const entries = config.upstreams;
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const name = Reflect.get(entry, "name");
+    const label = typeof name === "string" ? `"${name}"` : "with no name";
+    const isGit = "repo" in entry;
+    const required = isGit ? ["name", "repo", "ref", "commit", "handler"] : ["name", "npm", "version", "handler"];
+    for (const key of required) {
+      if (typeof Reflect.get(entry, key) !== "string") {
+        throw new TypeError(`upstreams.json: entry ${label} needs a string "${key}".`);
+      }
+    }
+    if (isGit && !Array.isArray(Reflect.get(entry, "paths"))) {
+      throw new Error(`upstreams.json: entry ${label} needs a "paths" array.`);
+    }
+    if (names.has(name)) {
+      throw new Error(`upstreams.json: the name ${label} is used twice.`);
+    }
+    names.add(name);
+  }
+  return config;
+}
+function planSync(status) {
+  return {
+    branch: `upstream/${status.entry.name}`,
+    status,
+    title: `chore(upstream): sync ${status.entry.name} to ${shorten(status.head)}`
+  };
+}
+async function syncUpstreams(options, dependencies) {
+  const config = parseUpstreamsConfig((0, import_node_fs.readFileSync)(options.configPath, "utf-8"));
+  const unknown = options.only.filter((name) => config.upstreams.every((entry) => entry.name !== name));
+  if (unknown.length > 0) {
+    throw new Error(`upstreams.json has no entry named ${unknown.map((name) => `"${name}"`).join(", ")}.`);
+  }
+  const results = [];
+  for (const entry of config.upstreams) {
+    if (options.only.length > 0 && !options.only.includes(entry.name)) {
+      continue;
+    }
+    try {
+      results.push(await syncEntry(entry, config, options, dependencies));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      dependencies.log(`${entry.name}: ERROR ${message}`);
+      results.push({ error: message, name: entry.name, outcome: "error" });
+    }
+  }
+  return results;
+}
+function writePin(configPath, status) {
+  const text = (0, import_node_fs.readFileSync)(configPath, "utf-8");
+  const parsed = JSON.parse(text);
+  const key = isGitUpstream(status.entry) ? "commit" : "version";
+  const target = parsed.upstreams.find((entry) => entry["name"] === status.entry.name);
+  if (target?.[key] !== status.pin) {
+    return;
+  }
+  target[key] = status.head;
+  (0, import_node_fs.writeFileSync)(configPath, `${JSON.stringify(parsed, null, JSON_INDENT_SPACES)}
+`);
+}
+function applyPlan(plan, config, options, dependencies) {
+  const { entry } = plan.status;
+  const env = { UPSTREAM_NAME: entry.name, UPSTREAM_TARGET: plan.status.head };
+  const handler = { command: entry.handler, result: dependencies.shell(entry.handler, env) };
+  writePin(options.configPath, plan.status);
+  const verifyCommand = entry.verify ?? config.verify;
+  const verify = verifyCommand === void 0 ? null : { command: verifyCommand, result: dependencies.shell(verifyCommand, env) };
+  const isFailed = handler.result.exitCode !== 0 || verify !== null && verify.result.exitCode !== 0;
+  execOrThrow(dependencies, "git", ["add", "--all"]);
+  execOrThrow(dependencies, "git", ["commit", "--no-verify", "--message", plan.title]);
+  const diffStat = execOrThrow(dependencies, "git", ["diff", "--stat", "HEAD~1", "HEAD"]);
+  const isRemoteBranch = dependencies.exec("git", ["ls-remote", "--exit-code", "--heads", "origin", plan.branch]).exitCode === 0;
+  if (isRemoteBranch) {
+    execOrThrow(dependencies, "git", ["fetch", "origin", plan.branch]);
+    if (dependencies.exec("git", ["diff", "--quiet", "FETCH_HEAD", "HEAD"]).exitCode === 0) {
+      dependencies.log(`${entry.name}: ${plan.branch} already holds this result; nothing pushed.`);
+      return { name: entry.name, outcome: "unchanged" };
+    }
+  }
+  execOrThrow(dependencies, "git", ["push", "--force", "origin", `HEAD:refs/heads/${plan.branch}`]);
+  const body = buildPrBody(plan, { handler, verify }, diffStat);
+  const existing = execOrThrow(dependencies, "gh", ["pr", "list", "--head", plan.branch, "--state", "open", "--json", "number", "--jq", ".[0].number"]).trim();
+  if (existing !== "" && existing !== "null") {
+    const prNumber2 = Number(existing);
+    execOrThrow(dependencies, "gh", ["pr", "edit", existing, "--title", plan.title, "--body", body]);
+    execOrThrow(dependencies, "gh", isFailed ? ["pr", "ready", existing, "--undo"] : ["pr", "ready", existing]);
+    dependencies.log(`${entry.name}: updated PR #${existing}${isFailed ? " (draft: a step failed)" : ""}.`);
+    return { name: entry.name, outcome: "updated", prNumber: prNumber2 };
+  }
+  const url = execOrThrow(dependencies, "gh", [
+    "pr",
+    "create",
+    "--base",
+    options.baseBranch,
+    "--head",
+    plan.branch,
+    "--title",
+    plan.title,
+    "--body",
+    body,
+    ...isFailed ? ["--draft"] : []
+  ]).trim();
+  dependencies.log(`${entry.name}: opened ${url}${isFailed ? " (draft: a step failed)" : ""}.`);
+  const prNumber = Number(/\/pull\/(?<Number>\d+)/.exec(url)?.groups?.["Number"] ?? NaN);
+  return Number.isNaN(prNumber) ? { name: entry.name, outcome: "opened" } : { name: entry.name, outcome: "opened", prNumber };
+}
+function describeStep(heading, step) {
+  const isPassed = step.result.exitCode === 0;
+  const tail = step.result.output.trimEnd().split(/\r?\n/).slice(-OUTPUT_TAIL_LINES).join("\n");
+  return [
+    `### ${heading}`,
+    "",
+    `\`${step.command}\`: ${isPassed ? "passed" : `**FAILED** (exit ${String(step.result.exitCode)})`}.`,
+    "",
+    isPassed ? "<details><summary>Output</summary>" : "<details open><summary>Output</summary>",
+    "",
+    "```text",
+    tail,
+    "```",
+    "",
+    "</details>",
+    ""
+  ];
+}
+function execOrThrow(dependencies, file, arguments_) {
+  const result = dependencies.exec(file, arguments_);
+  if (result.exitCode !== 0) {
+    throw new Error(`${file} ${arguments_.join(" ")} failed (exit ${String(result.exitCode)}): ${result.output.trim()}`);
+  }
+  return result.output;
+}
+function isGitUpstream(entry) {
+  return "repo" in entry;
+}
+function shorten(head) {
+  return /^[0-9a-f]{40}$/.test(head) ? head.slice(0, SHORT_SHA_LENGTH) : head;
+}
+async function syncEntry(entry, config, options, dependencies) {
+  const status = await compareWithUpstream(entry, dependencies);
+  if (status.state === "current") {
+    dependencies.log(`${entry.name}: current at ${shorten(status.head)}.`);
+    return { name: entry.name, outcome: "current" };
+  }
+  if (status.state === "unwatched") {
+    dependencies.log(`${entry.name}: moved to ${shorten(status.head)}, but no watched path changed since ${shorten(status.pin)}.`);
+    return { name: entry.name, outcome: "unwatched" };
+  }
+  const plan = planSync(status);
+  if (options.dryRun) {
+    dependencies.log(`${entry.name}: moved from ${shorten(status.pin)} to ${shorten(status.head)}. Would push ${plan.branch} and open:`);
+    dependencies.log(`  title: ${plan.title}`);
+    dependencies.log(buildPrBody(plan, null, null).replaceAll(/^/gm, "  | "));
+    return { name: entry.name, outcome: "planned" };
+  }
+  const dirty = execOrThrow(dependencies, "git", ["status", "--porcelain"]).trim();
+  if (dirty !== "") {
+    throw new Error(`the working tree is not clean, and the update commit would take these files with it:
+${dirty}`);
+  }
+  execOrThrow(dependencies, "git", ["fetch", "origin", options.baseBranch]);
+  execOrThrow(dependencies, "git", ["checkout", "-B", plan.branch, `origin/${options.baseBranch}`]);
+  try {
+    return applyPlan(plan, config, options, dependencies);
+  } finally {
+    dependencies.exec("git", ["checkout", "--force", options.baseBranch]);
+    dependencies.exec("git", ["branch", "--delete", "--force", plan.branch]);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildPrBody,
+  compareWithUpstream,
+  parseUpstreamsConfig,
+  planSync,
+  syncUpstreams,
+  writePin
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/upstream-sync.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Watches the upstreams a repository mirrors and opens one update PR per upstream that moved.\n *\n * Everything here is driven by `upstreams.json` and the handler commands it names, so any repository that vendors\n * upstream code can use it: through the `sync-upstreams` bin, or the reusable `sync-upstreams.yml` workflow.\n */\n\nimport {\n  readFileSync,\n  writeFileSync\n} from 'node:fs';\nimport { matchesGlob } from 'node:path';\n\n/**\n * What a command printed and how it exited.\n */\nexport interface CommandResult {\n  readonly exitCode: number;\n  readonly output: string;\n}\n\n/**\n * An upstream followed on a GitHub branch or tag, pinned to a commit.\n */\nexport interface GitUpstreamEntry {\n  /**\n   * The pinned commit: the last upstream state the handler was run against.\n   */\n  commit: string;\n  /**\n   * The shell command that turns a newer upstream state into changes in this repository.\n   */\n  handler: string;\n  name: string;\n  /**\n   * The paths watched upstream, as globs relative to the repository root. A move that touches none of them opens no PR.\n   */\n  paths: readonly string[];\n  /**\n   * The branch or tag followed.\n   */\n  ref: string;\n  /**\n   * `<owner>/<repo>` on GitHub.\n   */\n  repo: string;\n  /**\n   * The shell command that checks the handler's result. Overrides the file's top-level `verify`.\n   */\n  verify?: string;\n}\n\n/**\n * An upstream followed as an npm package's dist-tag, pinned to a version.\n */\nexport interface NpmUpstreamEntry {\n  handler: string;\n  name: string;\n  /**\n   * The package name.\n   */\n  npm: string;\n  /**\n   * The dist-tag followed. `latest` when absent.\n   */\n  tag?: string;\n  verify?: string;\n  /**\n   * The pinned version.\n   */\n  version: string;\n}\n\n/**\n * Everything the sync does to the outside world, so a test can stand a fixture in for it.\n */\nexport interface SyncDependencies {\n  /**\n   * Runs an executable with arguments and no shell.\n   */\n  exec: (file: string, arguments_: readonly string[], env?: Readonly<Record<string, string>>) => CommandResult;\n  /**\n   * GETs a URL and parses the JSON it returns, throwing on an HTTP error.\n   */\n  fetchJson: (url: string) => Promise<unknown>;\n  log: (text: string) => void;\n  /**\n   * Runs a command line through the shell: a handler or a verify command.\n   */\n  shell: (command: string, env?: Readonly<Record<string, string>>) => CommandResult;\n}\n\n/**\n * The PR an upstream move asks for.\n */\nexport interface SyncPlan {\n  branch: string;\n  status: UpstreamStatus;\n  title: string;\n}\n\n/**\n * What happened to one entry.\n */\nexport interface SyncResult {\n  /**\n   * Set when checking or applying threw: the job reports it and moves on to the next entry.\n   */\n  readonly error?: string;\n  readonly name: string;\n  /**\n   * `planned` in a dry run, `opened`/`updated` when a PR was pushed, `unchanged` when the branch already held this result.\n   */\n  readonly outcome: 'current' | 'error' | 'opened' | 'planned' | 'unchanged' | 'unwatched' | 'updated';\n  readonly prNumber?: number;\n}\n\n/**\n * What {@link syncUpstreams} syncs, and how.\n */\nexport interface SyncUpstreamsOptions {\n  /**\n   * The branch each PR targets and each update branch is cut from.\n   */\n  readonly baseBranch: string;\n  /**\n   * The path to `upstreams.json`, which the sync updates the pin in.\n   */\n  readonly configPath: string;\n  /**\n   * Plan and print every PR, and change nothing.\n   */\n  readonly dryRun: boolean;\n  /**\n   * Only the entries with these names, or every entry when empty.\n   */\n  readonly only: readonly string[];\n}\n\n/**\n * One upstream that `upstreams.json` lists: a git one or an npm one.\n */\nexport type UpstreamEntry = GitUpstreamEntry | NpmUpstreamEntry;\n\n/**\n * The content of `upstreams.json`.\n */\nexport interface UpstreamsConfig {\n  upstreams: readonly UpstreamEntry[];\n  /**\n   * The shell command that checks every handler's result, unless an entry names its own.\n   */\n  verify?: string;\n}\n\n/**\n * What one comparison of an entry with its upstream found.\n */\nexport interface UpstreamStatus {\n  /**\n   * The upstream paths that changed and are watched, sorted. Always empty for an npm upstream.\n   */\n  changedPaths: readonly string[];\n  /**\n   * A link that shows what changed between the pin and the head.\n   */\n  compareUrl: string;\n  entry: UpstreamEntry;\n  /**\n   * The commit or version the upstream is at now.\n   */\n  head: string;\n  /**\n   * The commit or version `upstreams.json` records.\n   */\n  pin: string;\n  /**\n   * `current`: nothing to do. `moved`: a PR is due. `unwatched`: upstream moved, but no watched path changed.\n   */\n  state: 'current' | 'moved' | 'unwatched';\n  /**\n   * Whether GitHub truncated the compare's file list, so a watched path may be missing from `changedPaths`.\n   */\n  truncated: boolean;\n}\n\ninterface GitHubCommit {\n  sha: string;\n}\n\ninterface GitHubCompare {\n  files?: readonly GitHubCompareFile[];\n}\n\n/**\n * One file of a GitHub compare, as the API spells it.\n */\ninterface GitHubCompareFile {\n  filename: string;\n\n  previous_filename?: string;\n}\n\ninterface NpmPackument {\n  'dist-tags': Record<string, string>;\n}\n\ninterface StepResult {\n  readonly command: string;\n  readonly result: CommandResult;\n}\n\n/**\n * The handler and verify runs a PR body reports.\n */\ninterface StepResults {\n  handler: StepResult;\n  verify: null | StepResult;\n}\n\n/**\n * `upstreams.json` read loosely, to write one value back without disturbing the rest.\n */\ninterface UpstreamsFileShape {\n  upstreams: Record<string, unknown>[];\n}\n\n/**\n * GitHub's compare API lists at most this many files, and says nothing when it stops.\n */\nconst COMPARE_FILE_LIMIT = 300;\n\nconst SHORT_SHA_LENGTH = 12;\n\n/**\n * The tail of a command's output a PR body quotes: enough to read a failure, short enough to stay under GitHub's body limit.\n */\nconst OUTPUT_TAIL_LINES = 60;\n\nconst JSON_INDENT_SPACES = 2;\n\n/**\n * Writes the PR body.\n *\n * @param plan - The plan.\n * @param steps - The handler and verify runs, or `null` in a dry run, where neither runs.\n * @param diffStat - `git diff --stat` of the update commit, or `null` in a dry run.\n * @returns The body, in Markdown.\n */\nexport function buildPrBody(plan: SyncPlan, steps: null | StepResults, diffStat: null | string): string {\n  const { entry, head, pin } = plan.status;\n  const source = isGitUpstream(entry) ? `\\`${entry.repo}@${entry.ref}\\`` : `npm \\`${entry.npm}@${entry.tag ?? 'latest'}\\``;\n  const lines = [\n    `Upstream \\`${entry.name}\\` moved: ${source} from \\`${pin}\\` to \\`${head}\\`.`,\n    '',\n    `Compare: ${plan.status.compareUrl}`,\n    ''\n  ];\n\n  if (isGitUpstream(entry)) {\n    lines.push('### Changed upstream files', '', ...plan.status.changedPaths.map((path) => `- \\`${path}\\``));\n    if (plan.status.truncated) {\n      lines.push(`- GitHub lists at most ${String(COMPARE_FILE_LIMIT)} files: open the compare link for the rest.`);\n    }\n    lines.push('');\n  }\n\n  if (steps === null) {\n    lines.push('### Handler', '', `\\`${entry.handler}\\`: not run (dry run).`, '');\n  } else {\n    lines.push(...describeStep('Handler', steps.handler));\n    if (steps.verify !== null) {\n      lines.push(...describeStep('Verify', steps.verify));\n    }\n  }\n\n  if (diffStat !== null) {\n    lines.push('### Generated changes', '', '```text', diffStat.trimEnd(), '```', '');\n  }\n\n  lines.push('This PR was opened by the upstream-sync job and is never merged automatically.');\n  return `${lines.join('\\n')}\\n`;\n}\n\n/**\n * Compares one entry with its upstream.\n *\n * @param entry - The entry.\n * @param dependencies - The outside world.\n * @returns What the comparison found.\n */\nexport async function compareWithUpstream(entry: UpstreamEntry, dependencies: Pick<SyncDependencies, 'fetchJson'>): Promise<UpstreamStatus> {\n  if (!isGitUpstream(entry)) {\n    const tag = entry.tag ?? 'latest';\n    const packument = await dependencies.fetchJson(`https://registry.npmjs.org/${entry.npm.replace('/', '%2f')}`) as NpmPackument;\n    const head = packument['dist-tags'][tag];\n    if (head === undefined) {\n      throw new Error(`npm package ${entry.npm} has no dist-tag \"${tag}\".`);\n    }\n    return {\n      changedPaths: [],\n      compareUrl: `https://www.npmjs.com/package/${entry.npm}/v/${head}`,\n      entry,\n      head,\n      pin: entry.version,\n      state: head === entry.version ? 'current' : 'moved',\n      truncated: false\n    };\n  }\n\n  const commit = await dependencies.fetchJson(`https://api.github.com/repos/${entry.repo}/commits/${encodeURIComponent(entry.ref)}`) as GitHubCommit;\n  const head = commit.sha;\n  const compareUrl = `https://github.com/${entry.repo}/compare/${entry.commit}...${head}`;\n  if (head === entry.commit) {\n    return { changedPaths: [], compareUrl, entry, head, pin: entry.commit, state: 'current', truncated: false };\n  }\n\n  const compare = await dependencies.fetchJson(`https://api.github.com/repos/${entry.repo}/compare/${entry.commit}...${head}`) as GitHubCompare;\n  const files = compare.files ?? [];\n  const touched = new Set(files.flatMap((file) => file.previous_filename === undefined ? [file.filename] : [file.filename, file.previous_filename]));\n  const changedPaths = [...touched].filter((path) => entry.paths.some((glob) => matchesGlob(path, glob))).sort();\n  const isTruncated = files.length >= COMPARE_FILE_LIMIT;\n  return {\n    changedPaths,\n    compareUrl,\n    entry,\n    head,\n    pin: entry.commit,\n    state: changedPaths.length > 0 || isTruncated ? 'moved' : 'unwatched',\n    truncated: isTruncated\n  };\n}\n\n/**\n * Parses and validates an `upstreams.json`.\n *\n * @param text - The file's content.\n * @returns The config.\n */\nexport function parseUpstreamsConfig(text: string): UpstreamsConfig {\n  const config = JSON.parse(text) as Partial<UpstreamsConfig>;\n  if (!Array.isArray(config.upstreams)) {\n    throw new TypeError('upstreams.json has no \"upstreams\" array.');\n  }\n  // Read through `Reflect.get`, because nothing about the parsed entries is known yet.\n  const entries: readonly object[] = config.upstreams;\n  const names = new Set<unknown>();\n  for (const entry of entries) {\n    const name: unknown = Reflect.get(entry, 'name');\n    const label = typeof name === 'string' ? `\"${name}\"` : 'with no name';\n    const isGit = 'repo' in entry;\n    const required = isGit ? ['name', 'repo', 'ref', 'commit', 'handler'] : ['name', 'npm', 'version', 'handler'];\n    for (const key of required) {\n      if (typeof Reflect.get(entry, key) !== 'string') {\n        throw new TypeError(`upstreams.json: entry ${label} needs a string \"${key}\".`);\n      }\n    }\n    if (isGit && !Array.isArray(Reflect.get(entry, 'paths'))) {\n      throw new Error(`upstreams.json: entry ${label} needs a \"paths\" array.`);\n    }\n    if (names.has(name)) {\n      throw new Error(`upstreams.json: the name ${label} is used twice.`);\n    }\n    names.add(name);\n  }\n  return config as UpstreamsConfig;\n}\n\n/**\n * Plans the PR a moved upstream asks for.\n *\n * @param status - The comparison of a moved entry.\n * @returns The branch and title.\n */\nexport function planSync(status: UpstreamStatus): SyncPlan {\n  return {\n    branch: `upstream/${status.entry.name}`,\n    status,\n    title: `chore(upstream): sync ${status.entry.name} to ${shorten(status.head)}`\n  };\n}\n\n/**\n * Checks every entry, and opens or updates one PR per moved upstream.\n *\n * A handler or verify failure still opens the PR, as a draft with the failure in its body, so a breaking upstream change\n * is seen rather than skipped. An error in the sync itself, such as a failed API call, is reported in the entry's result\n * and the next entry still runs.\n *\n * @param options - What to sync, and how.\n * @param dependencies - The outside world.\n * @returns One result per entry checked.\n */\nexport async function syncUpstreams(options: SyncUpstreamsOptions, dependencies: SyncDependencies): Promise<SyncResult[]> {\n  const config = parseUpstreamsConfig(readFileSync(options.configPath, 'utf-8'));\n  const unknown = options.only.filter((name) => config.upstreams.every((entry) => entry.name !== name));\n  if (unknown.length > 0) {\n    throw new Error(`upstreams.json has no entry named ${unknown.map((name) => `\"${name}\"`).join(', ')}.`);\n  }\n\n  const results: SyncResult[] = [];\n  for (const entry of config.upstreams) {\n    if (options.only.length > 0 && !options.only.includes(entry.name)) {\n      continue;\n    }\n    try {\n      results.push(await syncEntry(entry, config, options, dependencies));\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n      dependencies.log(`${entry.name}: ERROR ${message}`);\n      results.push({ error: message, name: entry.name, outcome: 'error' });\n    }\n  }\n  return results;\n}\n\n/**\n * Records `head` as the entry's pin in `upstreams.json`, unless the handler already moved it, keeping the file's\n * key order and formatting.\n *\n * @param configPath - The path to `upstreams.json`.\n * @param status - The comparison.\n */\nexport function writePin(configPath: string, status: UpstreamStatus): void {\n  const text = readFileSync(configPath, 'utf-8');\n  const parsed = JSON.parse(text) as UpstreamsFileShape;\n  const key = isGitUpstream(status.entry) ? 'commit' : 'version';\n  const target = parsed.upstreams.find((entry) => entry['name'] === status.entry.name);\n  if (target?.[key] !== status.pin) {\n    return;\n  }\n  target[key] = status.head;\n  writeFileSync(configPath, `${JSON.stringify(parsed, null, JSON_INDENT_SPACES)}\\n`);\n}\n\nfunction applyPlan(plan: SyncPlan, config: UpstreamsConfig, options: SyncUpstreamsOptions, dependencies: SyncDependencies): SyncResult {\n  const { entry } = plan.status;\n  const env = { UPSTREAM_NAME: entry.name, UPSTREAM_TARGET: plan.status.head };\n  const handler: StepResult = { command: entry.handler, result: dependencies.shell(entry.handler, env) };\n  writePin(options.configPath, plan.status);\n  const verifyCommand = entry.verify ?? config.verify;\n  const verify: null | StepResult = verifyCommand === undefined ? null : { command: verifyCommand, result: dependencies.shell(verifyCommand, env) };\n  const isFailed = handler.result.exitCode !== 0 || (verify !== null && verify.result.exitCode !== 0);\n\n  execOrThrow(dependencies, 'git', ['add', '--all']);\n  execOrThrow(dependencies, 'git', ['commit', '--no-verify', '--message', plan.title]);\n  const diffStat = execOrThrow(dependencies, 'git', ['diff', '--stat', 'HEAD~1', 'HEAD']);\n\n  const isRemoteBranch = dependencies.exec('git', ['ls-remote', '--exit-code', '--heads', 'origin', plan.branch]).exitCode === 0;\n  if (isRemoteBranch) {\n    execOrThrow(dependencies, 'git', ['fetch', 'origin', plan.branch]);\n    if (dependencies.exec('git', ['diff', '--quiet', 'FETCH_HEAD', 'HEAD']).exitCode === 0) {\n      dependencies.log(`${entry.name}: ${plan.branch} already holds this result; nothing pushed.`);\n      return { name: entry.name, outcome: 'unchanged' };\n    }\n  }\n  execOrThrow(dependencies, 'git', ['push', '--force', 'origin', `HEAD:refs/heads/${plan.branch}`]);\n\n  const body = buildPrBody(plan, { handler, verify }, diffStat);\n  const existing = execOrThrow(dependencies, 'gh', ['pr', 'list', '--head', plan.branch, '--state', 'open', '--json', 'number', '--jq', '.[0].number']).trim();\n  if (existing !== '' && existing !== 'null') {\n    const prNumber = Number(existing);\n    execOrThrow(dependencies, 'gh', ['pr', 'edit', existing, '--title', plan.title, '--body', body]);\n    execOrThrow(dependencies, 'gh', isFailed ? ['pr', 'ready', existing, '--undo'] : ['pr', 'ready', existing]);\n    dependencies.log(`${entry.name}: updated PR #${existing}${isFailed ? ' (draft: a step failed)' : ''}.`);\n    return { name: entry.name, outcome: 'updated', prNumber };\n  }\n\n  const url = execOrThrow(dependencies, 'gh', [\n    'pr',\n    'create',\n    '--base',\n    options.baseBranch,\n    '--head',\n    plan.branch,\n    '--title',\n    plan.title,\n    '--body',\n    body,\n    ...(isFailed ? ['--draft'] : [])\n  ]).trim();\n  dependencies.log(`${entry.name}: opened ${url}${isFailed ? ' (draft: a step failed)' : ''}.`);\n  const prNumber = Number(/\\/pull\\/(?<Number>\\d+)/.exec(url)?.groups?.['Number'] ?? NaN);\n  return Number.isNaN(prNumber) ? { name: entry.name, outcome: 'opened' } : { name: entry.name, outcome: 'opened', prNumber };\n}\n\nfunction describeStep(heading: string, step: StepResult): string[] {\n  const isPassed = step.result.exitCode === 0;\n  const tail = step.result.output.trimEnd().split(/\\r?\\n/).slice(-OUTPUT_TAIL_LINES).join('\\n');\n  return [\n    `### ${heading}`,\n    '',\n    `\\`${step.command}\\`: ${isPassed ? 'passed' : `**FAILED** (exit ${String(step.result.exitCode)})`}.`,\n    '',\n    isPassed ? '<details><summary>Output</summary>' : '<details open><summary>Output</summary>',\n    '',\n    '```text',\n    tail,\n    '```',\n    '',\n    '</details>',\n    ''\n  ];\n}\n\nfunction execOrThrow(dependencies: SyncDependencies, file: string, arguments_: readonly string[]): string {\n  const result = dependencies.exec(file, arguments_);\n  if (result.exitCode !== 0) {\n    throw new Error(`${file} ${arguments_.join(' ')} failed (exit ${String(result.exitCode)}): ${result.output.trim()}`);\n  }\n  return result.output;\n}\n\nfunction isGitUpstream(entry: UpstreamEntry): entry is GitUpstreamEntry {\n  return 'repo' in entry;\n}\n\nfunction shorten(head: string): string {\n  return /^[0-9a-f]{40}$/.test(head) ? head.slice(0, SHORT_SHA_LENGTH) : head;\n}\n\nasync function syncEntry(entry: UpstreamEntry, config: UpstreamsConfig, options: SyncUpstreamsOptions, dependencies: SyncDependencies): Promise<SyncResult> {\n  const status = await compareWithUpstream(entry, dependencies);\n  if (status.state === 'current') {\n    dependencies.log(`${entry.name}: current at ${shorten(status.head)}.`);\n    return { name: entry.name, outcome: 'current' };\n  }\n  if (status.state === 'unwatched') {\n    dependencies.log(`${entry.name}: moved to ${shorten(status.head)}, but no watched path changed since ${shorten(status.pin)}.`);\n    return { name: entry.name, outcome: 'unwatched' };\n  }\n\n  const plan = planSync(status);\n  if (options.dryRun) {\n    dependencies.log(`${entry.name}: moved from ${shorten(status.pin)} to ${shorten(status.head)}. Would push ${plan.branch} and open:`);\n    dependencies.log(`  title: ${plan.title}`);\n    dependencies.log(buildPrBody(plan, null, null).replaceAll(/^/gm, '  | '));\n    return { name: entry.name, outcome: 'planned' };\n  }\n\n  // The update commit takes every file in the tree, so a file left lying around would be pushed with it.\n  const dirty = execOrThrow(dependencies, 'git', ['status', '--porcelain']).trim();\n  if (dirty !== '') {\n    throw new Error(`the working tree is not clean, and the update commit would take these files with it:\\n${dirty}`);\n  }\n  execOrThrow(dependencies, 'git', ['fetch', 'origin', options.baseBranch]);\n  execOrThrow(dependencies, 'git', ['checkout', '-B', plan.branch, `origin/${options.baseBranch}`]);\n  try {\n    return applyPlan(plan, config, options, dependencies);\n  } finally {\n    dependencies.exec('git', ['checkout', '--force', options.baseBranch]);\n    dependencies.exec('git', ['branch', '--delete', '--force', plan.branch]);\n  }\n}\n"],
  "mappings": "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",
  "names": ["head", "prNumber"]
}


package/dist/lib/cjs/upstream-sync.d.cts

@@ -0,0 +1,235 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * Watches the upstreams a repository mirrors and opens one update PR per upstream that moved.
+ *
+ * Everything here is driven by `upstreams.json` and the handler commands it names, so any repository that vendors
+ * upstream code can use it: through the `sync-upstreams` bin, or the reusable `sync-upstreams.yml` workflow.
+ */
+/**
+ * What a command printed and how it exited.
+ */
+export interface CommandResult {
+    readonly exitCode: number;
+    readonly output: string;
+}
+/**
+ * An upstream followed on a GitHub branch or tag, pinned to a commit.
+ */
+export interface GitUpstreamEntry {
+    /**
+     * The pinned commit: the last upstream state the handler was run against.
+     */
+    commit: string;
+    /**
+     * The shell command that turns a newer upstream state into changes in this repository.
+     */
+    handler: string;
+    name: string;
+    /**
+     * The paths watched upstream, as globs relative to the repository root. A move that touches none of them opens no PR.
+     */
+    paths: readonly string[];
+    /**
+     * The branch or tag followed.
+     */
+    ref: string;
+    /**
+     * `<owner>/<repo>` on GitHub.
+     */
+    repo: string;
+    /**
+     * The shell command that checks the handler's result. Overrides the file's top-level `verify`.
+     */
+    verify?: string;
+}
+/**
+ * An upstream followed as an npm package's dist-tag, pinned to a version.
+ */
+export interface NpmUpstreamEntry {
+    handler: string;
+    name: string;
+    /**
+     * The package name.
+     */
+    npm: string;
+    /**
+     * The dist-tag followed. `latest` when absent.
+     */
+    tag?: string;
+    verify?: string;
+    /**
+     * The pinned version.
+     */
+    version: string;
+}
+/**
+ * Everything the sync does to the outside world, so a test can stand a fixture in for it.
+ */
+export interface SyncDependencies {
+    /**
+     * Runs an executable with arguments and no shell.
+     */
+    exec: (file: string, arguments_: readonly string[], env?: Readonly<Record<string, string>>) => CommandResult;
+    /**
+     * GETs a URL and parses the JSON it returns, throwing on an HTTP error.
+     */
+    fetchJson: (url: string) => Promise<unknown>;
+    log: (text: string) => void;
+    /**
+     * Runs a command line through the shell: a handler or a verify command.
+     */
+    shell: (command: string, env?: Readonly<Record<string, string>>) => CommandResult;
+}
+/**
+ * The PR an upstream move asks for.
+ */
+export interface SyncPlan {
+    branch: string;
+    status: UpstreamStatus;
+    title: string;
+}
+/**
+ * What happened to one entry.
+ */
+export interface SyncResult {
+    /**
+     * Set when checking or applying threw: the job reports it and moves on to the next entry.
+     */
+    readonly error?: string;
+    readonly name: string;
+    /**
+     * `planned` in a dry run, `opened`/`updated` when a PR was pushed, `unchanged` when the branch already held this result.
+     */
+    readonly outcome: 'current' | 'error' | 'opened' | 'planned' | 'unchanged' | 'unwatched' | 'updated';
+    readonly prNumber?: number;
+}
+/**
+ * What {@link syncUpstreams} syncs, and how.
+ */
+export interface SyncUpstreamsOptions {
+    /**
+     * The branch each PR targets and each update branch is cut from.
+     */
+    readonly baseBranch: string;
+    /**
+     * The path to `upstreams.json`, which the sync updates the pin in.
+     */
+    readonly configPath: string;
+    /**
+     * Plan and print every PR, and change nothing.
+     */
+    readonly dryRun: boolean;
+    /**
+     * Only the entries with these names, or every entry when empty.
+     */
+    readonly only: readonly string[];
+}
+/**
+ * One upstream that `upstreams.json` lists: a git one or an npm one.
+ */
+export type UpstreamEntry = GitUpstreamEntry | NpmUpstreamEntry;
+/**
+ * The content of `upstreams.json`.
+ */
+export interface UpstreamsConfig {
+    upstreams: readonly UpstreamEntry[];
+    /**
+     * The shell command that checks every handler's result, unless an entry names its own.
+     */
+    verify?: string;
+}
+/**
+ * What one comparison of an entry with its upstream found.
+ */
+export interface UpstreamStatus {
+    /**
+     * The upstream paths that changed and are watched, sorted. Always empty for an npm upstream.
+     */
+    changedPaths: readonly string[];
+    /**
+     * A link that shows what changed between the pin and the head.
+     */
+    compareUrl: string;
+    entry: UpstreamEntry;
+    /**
+     * The commit or version the upstream is at now.
+     */
+    head: string;
+    /**
+     * The commit or version `upstreams.json` records.
+     */
+    pin: string;
+    /**
+     * `current`: nothing to do. `moved`: a PR is due. `unwatched`: upstream moved, but no watched path changed.
+     */
+    state: 'current' | 'moved' | 'unwatched';
+    /**
+     * Whether GitHub truncated the compare's file list, so a watched path may be missing from `changedPaths`.
+     */
+    truncated: boolean;
+}
+interface StepResult {
+    readonly command: string;
+    readonly result: CommandResult;
+}
+/**
+ * The handler and verify runs a PR body reports.
+ */
+interface StepResults {
+    handler: StepResult;
+    verify: null | StepResult;
+}
+/**
+ * Writes the PR body.
+ *
+ * @param plan - The plan.
+ * @param steps - The handler and verify runs, or `null` in a dry run, where neither runs.
+ * @param diffStat - `git diff --stat` of the update commit, or `null` in a dry run.
+ * @returns The body, in Markdown.
+ */
+export declare function buildPrBody(plan: SyncPlan, steps: null | StepResults, diffStat: null | string): string;
+/**
+ * Compares one entry with its upstream.
+ *
+ * @param entry - The entry.
+ * @param dependencies - The outside world.
+ * @returns What the comparison found.
+ */
+export declare function compareWithUpstream(entry: UpstreamEntry, dependencies: Pick<SyncDependencies, 'fetchJson'>): Promise<UpstreamStatus>;
+/**
+ * Parses and validates an `upstreams.json`.
+ *
+ * @param text - The file's content.
+ * @returns The config.
+ */
+export declare function parseUpstreamsConfig(text: string): UpstreamsConfig;
+/**
+ * Plans the PR a moved upstream asks for.
+ *
+ * @param status - The comparison of a moved entry.
+ * @returns The branch and title.
+ */
+export declare function planSync(status: UpstreamStatus): SyncPlan;
+/**
+ * Checks every entry, and opens or updates one PR per moved upstream.
+ *
+ * A handler or verify failure still opens the PR, as a draft with the failure in its body, so a breaking upstream change
+ * is seen rather than skipped. An error in the sync itself, such as a failed API call, is reported in the entry's result
+ * and the next entry still runs.
+ *
+ * @param options - What to sync, and how.
+ * @param dependencies - The outside world.
+ * @returns One result per entry checked.
+ */
+export declare function syncUpstreams(options: SyncUpstreamsOptions, dependencies: SyncDependencies): Promise<SyncResult[]>;
+/**
+ * Records `head` as the entry's pin in `upstreams.json`, unless the handler already moved it, keeping the file's
+ * key order and formatting.
+ *
+ * @param configPath - The path to `upstreams.json`.
+ * @param status - The comparison.
+ */
+export declare function writePin(configPath: string, status: UpstreamStatus): void;
+export {};