@node-core/utils 4.0.0

package/lib/backport_session.js

@@ -0,0 +1,302 @@
+import Session from './session.js';
+import { runSync, runAsync, IGNORE } from './run.js';
+import { getPrURL, parsePrURL } from './links.js';
+
+const MAX_HISTORY = 10;
+const OLDEST_ID = new Map([
+  [8, 13000],
+  [10, 20000],
+  [11, 23000]
+]);
+
+export default class BackportSession extends Session {
+  constructor(cli, dir, prid, target) {
+    super(cli, dir, prid);
+    this.target = target;
+  }
+
+  getChangedFiles(rev) {
+    return runSync('git',
+      ['diff-tree', '--no-commit-id', '--name-only', '-r', rev]
+    ).trim().split('\n');
+  }
+
+  getPreviousCommits(rev, file, num) {
+    let logs;
+    try {
+      logs = runSync('git',
+        ['log', `-${num}`, '--format=%h', rev, '--', file]
+      ).trim();
+    } catch (e) {
+      return null;
+    }
+    if (!logs) {
+      return [];
+    }
+
+    return logs.trim().split('\n');
+  }
+
+  getCommitMessage(rev) {
+    return runSync('git',
+      ['show', '--format=%B', '-s', rev]
+    ).trim();
+  }
+
+  get stagingBranch() {
+    return `v${this.target}.x-staging`;
+  }
+
+  getPotentialConflicts(rev, targetBranch) {
+    const { cli } = this;
+    const files = this.getChangedFiles(rev);
+    const notBackported = new Map();
+    const oldest = OLDEST_ID.get(this.target);
+    for (const file of files) {
+      cli.startSpinner(`Analyzing ancestors of ${file}`);
+      // TODO(joyeecheung): if the file does not exit in the current revision,
+      // warn about it and skip it.
+      const ancestors = this.getPreviousCommits(`${rev}~1`, file, MAX_HISTORY);
+      if (!ancestors) {
+        cli.stopSpinner(`${file} does not exist in current working tree`,
+          cli.SPINNER_STATUS.WARN);
+        continue;
+      }
+      if (ancestors.length === 0) {
+        cli.stopSpinner(`Cannot find ancestor commits of ${file}`,
+          cli.SPINNER_STATUS.INFO);
+        continue;
+      }
+      for (const ancestor of ancestors) {
+        const message = this.getCommitMessage(ancestor);
+        cli.updateSpinner(`Analyzing ${message.split('\n')[0]}...`);
+        let data = parsePrURL(message);
+        if (!data) {
+          const match = message.match('/^PR-URL: #(\\d+)/');
+          if (!match) {
+            cli.stopSpinner(
+              `Commit message of ${ancestor} is ill-formed, skipping`,
+              cli.SPINNER_STATUS.WARN);
+            cli.startSpinner(`Analyzing ancestors of ${file}`);
+            continue;
+          }
+          data = {
+            repo: this.repo,
+            owner: this.owner,
+            prid: parseInt(match[1])
+          };
+        }
+        if (data.prid < oldest) {
+          cli.updateSpinner(
+            `Commit ${ancestor} iS too old, skipping`,
+            cli.SPINNER_STATUS.WARN);
+          break;
+        }
+        const backported = this.getCommitsFromBranch(
+          data.prid, targetBranch
+        );
+        if (backported.length === 0) {
+          const record = notBackported.get(ancestor);
+          if (record) {
+            record.files.add(file);
+          } else {
+            notBackported.set(ancestor, {
+              prid: data.prid,
+              url: getPrURL(data),
+              commit: ancestor,
+              title: message.split('\n')[0],
+              files: new Set([file])
+            });
+          }
+        }
+      }
+      cli.stopSpinner(`Analyzed ${file}`);
+    }
+    return notBackported;
+  }
+
+  warnForPotentialConflicts(rev) {
+    const { cli } = this;
+    const staging = this.stagingBranch;
+
+    cli.log(`Looking for potential conflicts of ${rev}...`);
+    const notBackported = this.getPotentialConflicts(rev, staging);
+
+    if (notBackported.size === 0) {
+      cli.info(`All ancestor commits of ${rev} have been backported`);
+      return;
+    }
+
+    cli.warn(`The following ancestor commits of ${rev} are not on ${staging}`);
+    for (const [commit, data] of notBackported) {
+      cli.log(`  - ${commit} ${data.title}, ${data.url}`);
+      for (const file of data.files) {
+        cli.log(`    ${file}`);
+      }
+    }
+  }
+
+  async backport() {
+    const { cli } = this;
+    // TODO(joyeechuneg): add more warnings
+    const { prid } = this;
+    const url = getPrURL(this);
+    cli.log(`Looking for commits of ${url} on main...`);
+
+    const commits = this.getCommitsFromBranch(prid, 'main');
+
+    if (commits.length === 0) {
+      cli.error('Could not find any commit matching the PR');
+      throw new Error(IGNORE);
+    }
+
+    cli.ok('Found the following commits:');
+    for (const commit of commits) {
+      cli.log(`    - ${commit.sha} ${commit.title}`);
+    }
+
+    if (!this.isLocalBranchExists(this.stagingBranch)) {
+      const shouldCreateStagingBranch = await cli.prompt(
+        `It seems like ${this.stagingBranch} is missing locally, ` +
+        'do you want to create it locally to get ready for backporting?', {
+          defaultAnswer: true
+        });
+
+      if (shouldCreateStagingBranch) {
+        this.syncBranchWithUpstream(this.stagingBranch);
+      }
+    } else if (!this.isBranchUpToDateWithUpstream(this.stagingBranch)) {
+      const shouldSyncBranch = await cli.prompt(
+        `It seems like your ${this.stagingBranch} is behind the ${this.upstream} remote ` +
+        'do you want to sync it?', { defaultAnswer: true });
+
+      if (shouldSyncBranch) {
+        this.syncBranchWithUpstream(this.stagingBranch);
+      }
+    }
+
+    const newBranch = `backport-${this.prid}-to-${this.target}`;
+    const shouldCheckout = await cli.prompt(
+      `Do you want to checkout to a new branch \`${newBranch}\`` +
+      ' to start backporting?', { defaultAnswer: false });
+
+    if (shouldCheckout) {
+      await runAsync('git', ['checkout', '-b', newBranch, this.stagingBranch]);
+    }
+
+    const shouldAnalyze = await cli.prompt(
+      'Do you want to analyze the dependencies of the commits? ' +
+      '(this could take a while)');
+    if (shouldAnalyze) {
+      for (const commit of commits) {
+        this.warnForPotentialConflicts(commit.sha);
+      }
+    }
+
+    const cherries = commits.map(i => i.sha).reverse();
+    const pendingCommands = [
+      `git cherry-pick ${cherries.join(' ')}`,
+      'git push -u <your-fork-remote> <your-branch-name>'
+    ];
+    const shouldPick = await cli.prompt(
+      'Do you want to cherry-pick the commits?');
+    if (!shouldPick) {
+      this.hintCommands(pendingCommands);
+      return;
+    }
+
+    cli.log(`Running \`${pendingCommands[0]}\`...`);
+    pendingCommands.shift();
+    await runAsync('git', ['cherry-pick', ...cherries]);
+    this.hintCommands(pendingCommands);
+  }
+
+  hintCommands(commands) {
+    this.cli.log('Tips: run the following commands to complete backport');
+    for (const command of commands) {
+      this.cli.log(`$ ${command}`);
+    }
+  }
+
+  getCommitsFromBranch(prid, branch, loose = true) {
+    let re;
+    const url = getPrURL({ prid, repo: this.repo, owner: this.owner });
+    re = `--grep=PR-URL: ${url}`;
+
+    let commits = runSync('git', [
+      'log', re, '--format=%h %s', branch
+    ]).trim();
+    if (!commits) {
+      if (!loose) {
+        return [];
+      }
+      re = `--grep=PR-URL: #${prid}\\b`;
+      commits = runSync('git', [
+        'log', re, '--format=%h %s', branch
+      ]).trim();
+      if (!commits) {
+        return [];
+      }
+    }
+
+    return commits.split('\n').map((i) => {
+      const match = i.match(/(\w+) (.+)/);
+      return {
+        sha: match[1],
+        title: match[2]
+      };
+    });
+  }
+
+  getCurrentBranch() {
+    return runSync('git',
+      ['rev-parse', '--abbrev-ref', 'HEAD']
+    ).trim();
+  }
+
+  updateUpstreamRefs(branchName) {
+    runSync('git',
+      ['fetch', this.upstream, branchName]
+    );
+  }
+
+  getBranchCommit(branch) {
+    return runSync('git',
+      ['rev-parse', branch]
+    ).trim();
+  }
+
+  isBranchUpToDateWithUpstream(branch) {
+    this.updateUpstreamRefs(branch);
+
+    const localCommit = this.getBranchCommit(branch);
+    const upstreamCommit = this.getBranchCommit(`${this.upstream}/${branch}`);
+
+    return localCommit === upstreamCommit;
+  };
+
+  isLocalBranchExists(branch) {
+    try {
+      // will exit with code 1 if branch does not exist
+      runSync('git',
+        ['rev-parse', '--verify', '--quiet', branch]
+      );
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  syncBranchWithUpstream(branch) {
+    const currentBranch = this.getCurrentBranch();
+
+    runSync('git',
+      [
+        currentBranch !== branch ? 'fetch' : 'pull',
+        this.upstream,
+        `${branch}:${branch}`,
+        '-f'
+      ]
+    );
+  }
+}

package/lib/cache.js

@@ -0,0 +1,107 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+import { writeJson, readJson, writeFile, readFile } from './file.js';
+
+function isAsync(fn) {
+  return fn[Symbol.toStringTag] === 'AsyncFunction';
+}
+
+const parentDir = fileURLToPath(new URL('..', import.meta.url));
+
+export default class Cache {
+  constructor(dir) {
+    this.dir = dir || this.computeCacheDir(parentDir);
+    this.originals = {};
+    this.disabled = true;
+  }
+
+  computeCacheDir(base) {
+    return path.join(base, '.ncu', 'cache');
+  }
+
+  disable() {
+    this.disabled = true;
+  }
+
+  enable() {
+    this.disabled = false;
+  }
+
+  getFilename(key, ext) {
+    return path.join(this.dir, key) + ext;
+  }
+
+  has(key, ext) {
+    if (this.disabled) {
+      return false;
+    }
+
+    return fs.existsSync(this.getFilename(key, ext));
+  }
+
+  get(key, ext) {
+    if (!this.has(key, ext)) {
+      return undefined;
+    }
+    if (ext === '.json') {
+      return readJson(this.getFilename(key, ext));
+    } else {
+      return readFile(this.getFilename(key, ext));
+    }
+  }
+
+  write(key, ext, content) {
+    if (this.disabled) {
+      return;
+    }
+    const filename = this.getFilename(key, ext);
+    if (ext === '.json') {
+      return writeJson(filename, content);
+    } else {
+      return writeFile(filename, content);
+    }
+  }
+
+  wrapAsync(original, identity) {
+    const cache = this;
+    return async function(...args) {
+      const { key, ext } = identity.call(this, ...args);
+      const cached = cache.get(key, ext);
+      if (cached) {
+        return cached;
+      }
+      const result = await original.call(this, ...args);
+      cache.write(key, ext, result);
+      return result;
+    };
+  }
+
+  wrapNormal(original, identity) {
+    const cache = this;
+    return function(...args) {
+      const { key, ext } = identity.call(this, ...args);
+      const cached = cache.get(key, ext);
+      if (cached) {
+        return cached;
+      }
+      const result = original.call(this, ...args);
+      cache.write(key, ext, result);
+      return result;
+    };
+  }
+
+  wrap(Class, identities) {
+    for (const method of Object.keys(identities)) {
+      const original = Class.prototype[method];
+      const identity = identities[method];
+      this.originals[method] = original;
+      if (isAsync(original)) {
+        Class.prototype[method] = this.wrapAsync(original, identity);
+      } else {
+        Class.prototype[method] = this.wrapNormal(original, identity);
+      }
+    }
+  }
+}

package/lib/cherry_pick.js

@@ -0,0 +1,304 @@
+import os from 'node:os';
+import path from 'node:path';
+import { getMetadata } from '../components/metadata.js';
+
+import {
+  runAsync, runSync, forceRunAsync
+} from './run.js';
+import { writeFile } from './file.js';
+import {
+  shortSha, getEditor
+} from './utils.js';
+import { getNcuDir } from './config.js';
+
+const LINT_RESULTS = {
+  SKIPPED: 'skipped',
+  FAILED: 'failed',
+  SUCCESS: 'success'
+};
+
+export default class CheckPick {
+  constructor(prid, dir, cli, {
+    owner,
+    repo,
+    lint,
+    includeCVE
+  } = {}) {
+    this.prid = prid;
+    this.cli = cli;
+    this.dir = dir;
+    this.options = { owner, repo, lint, includeCVE };
+  }
+
+  get includeCVE() {
+    return this.options.includeCVE ?? false;
+  }
+
+  get owner() {
+    return this.options.owner || 'nodejs';
+  }
+
+  get repo() {
+    return this.options.repo || 'node';
+  }
+
+  get lint() {
+    return this.options.lint;
+  }
+
+  getUpstreamHead() {
+    const { upstream, branch } = this;
+    return runSync('git', ['rev-parse', `${upstream}/${branch}`]).trim();
+  }
+
+  getCurrentRev() {
+    return runSync('git', ['rev-parse', 'HEAD']).trim();
+  }
+
+  getStrayCommits(verbose) {
+    const { upstream, branch } = this;
+    const ref = `${upstream}/${branch}...HEAD`;
+    const gitCmd = verbose
+      ? ['log', '--oneline', '--reverse', ref]
+      : ['rev-list', '--reverse', ref];
+    const revs = runSync('git', gitCmd).trim();
+    return revs ? revs.split('\n') : [];
+  }
+
+  get ncuDir() {
+    return getNcuDir(this.dir);
+  }
+
+  get pullDir() {
+    return path.resolve(this.ncuDir, `${this.prid}`);
+  }
+
+  getMessagePath(rev) {
+    return path.resolve(this.pullDir, `${shortSha(rev)}.COMMIT_EDITMSG`);
+  }
+
+  saveMessage(rev, message) {
+    const file = this.getMessagePath(rev);
+    writeFile(file, message);
+    return file;
+  }
+
+  async start() {
+    const { cli } = this;
+
+    const metadata = await getMetadata({
+      prid: this.prid,
+      owner: this.owner,
+      repo: this.repo
+    }, false, cli);
+    const expectedCommitShas =
+      metadata.data.commits.map(({ commit }) => commit.oid);
+
+    const amend = await cli.prompt(
+      'Would you like to amend this PR to the proposal?',
+      { default: true }
+    );
+
+    if (!amend) {
+      return true;
+    }
+
+    try {
+      const commitInfo = await this.downloadAndPatch(expectedCommitShas);
+      const cleanLint = await this.validateLint();
+      if (cleanLint === LINT_RESULTS.FAILED) {
+        cli.error('Patch still contains lint errors. ' +
+          'Please fix manually before proceeding');
+        return false;
+      } else if (cleanLint === LINT_RESULTS.SUCCESS) {
+        cli.ok('Lint passed cleanly');
+      }
+      return this.amend(metadata.metadata, commitInfo);
+    } catch (e) {
+      cli.error(e.message);
+      return false;
+    }
+  }
+
+  async downloadAndPatch(expectedCommitShas) {
+    const { cli, repo, owner, prid } = this;
+
+    cli.startSpinner(`Downloading patch for ${prid}`);
+    // fetch via ssh to handle private repo
+    await runAsync('git', [
+      'fetch', `git@github.com:${owner}/${repo}.git`,
+      `refs/pull/${prid}/merge`]);
+    // We fetched the commit that would result if we used `git merge`.
+    // ^1 and ^2 refer to the PR base and the PR head, respectively.
+    const [base, head] = await runAsync('git',
+      ['rev-parse', 'FETCH_HEAD^1', 'FETCH_HEAD^2'],
+      { captureStdout: 'lines' });
+    const commitShas = await runAsync('git',
+      ['rev-list', `${base}..${head}`],
+      { captureStdout: 'lines' });
+    cli.stopSpinner(`Fetched commits as ${shortSha(base)}..${shortSha(head)}`);
+    cli.separator();
+
+    const mismatchedCommits = [
+      ...commitShas.filter((sha) => !expectedCommitShas.includes(sha))
+        .map((sha) => `Unexpected commit ${sha}`),
+      ...expectedCommitShas.filter((sha) => !commitShas.includes(sha))
+        .map((sha) => `Missing commit ${sha}`)
+    ].join('\n');
+    if (mismatchedCommits.length > 0) {
+      throw new Error(`Mismatched commits:\n${mismatchedCommits}`);
+    }
+
+    const commitInfo = { base, head, shas: commitShas };
+
+    try {
+      await forceRunAsync('git', ['cherry-pick', `${base}..${head}`], {
+        ignoreFailure: false
+      });
+    } catch (ex) {
+      await forceRunAsync('git', ['cherry-pick', '--abort']);
+      throw new Error('Failed to apply patches');
+    }
+
+    cli.ok('Patches applied');
+    return commitInfo;
+  }
+
+  async validateLint() {
+    // The linter is currently only run on non-Windows platforms.
+    if (os.platform() === 'win32') {
+      return LINT_RESULTS.SKIPPED;
+    }
+
+    if (!this.lint) {
+      return LINT_RESULTS.SKIPPED;
+    }
+
+    try {
+      await runAsync('make', ['lint']);
+      return LINT_RESULTS.SUCCESS;
+    } catch {
+      return LINT_RESULTS.FAILED;
+    }
+  }
+
+  async amend(metadata, commitInfo) {
+    const { cli } = this;
+    const subjects = await runAsync('git',
+      ['log', '--pretty=format:%s', `${commitInfo.base}..${commitInfo.head}`],
+      { captureStdout: 'lines' });
+
+    if (commitInfo.shas.length !== 1) {
+      const fixupAll = await cli.prompt(
+        `${subjects.length} commits from the original PR are going to be` +
+        'squashed into a single commit. OK to proceed?', {
+          defaultAnswer: true
+        });
+      if (!fixupAll) {
+        // TODO: add this support?
+        throw new Error(`There are ${subjects.length} commits in the PR ` +
+          'and the ammend were not able to succeed');
+      }
+      await runAsync('git', ['reset', '--soft', `HEAD~${subjects.length - 1}`]);
+      await runAsync('git', ['commit', '--amend', '--no-edit']);
+    }
+
+    return this._amend(metadata);
+  }
+
+  async _amend(metadataStr) {
+    const { cli } = this;
+
+    const rev = this.getCurrentRev();
+    const original = runSync('git', [
+      'show', 'HEAD', '-s', '--format=%B'
+    ]).trim();
+    // git has very specific rules about what is a trailer and what is not.
+    // Instead of trying to implement those ourselves, let git parse the
+    // original commit message and see if it outputs any trailers.
+    const originalHasTrailers = runSync('git', [
+      'interpret-trailers', '--parse', '--no-divider'
+    ], {
+      input: `${original}\n`
+    }).trim().length !== 0;
+    const metadata = metadataStr.trim().split('\n');
+    const amended = original.split('\n');
+
+    // If the original commit message already contains trailers (such as
+    // "Co-authored-by"), we simply add our own metadata after those. Otherwise,
+    // we have to add an empty line so that git recognizes our own metadata as
+    // trailers in the amended commit message.
+    if (!originalHasTrailers) {
+      amended.push('');
+    }
+
+    const BACKPORT_RE = /BACKPORT-PR-URL\s*:\s*(\S+)/i;
+    const PR_RE = /PR-URL\s*:\s*(\S+)/i;
+    const REVIEW_RE = /Reviewed-By\s*:\s*(\S+)/i;
+    const CVE_RE = /CVE-ID\s*:\s*(\S+)/i;
+
+    let containCVETrailer = false;
+    for (const line of metadata) {
+      if (line.length !== 0 && original.includes(line)) {
+        if (line.match(CVE_RE)) {
+          containCVETrailer = true;
+        }
+        if (originalHasTrailers) {
+          cli.warn(`Found ${line}, skipping..`);
+        } else {
+          throw new Error(
+            'Git found no trailers in the original commit message, ' +
+            `but '${line}' is present and should be a trailer.`);
+        }
+      } else {
+        if (line.match(BACKPORT_RE)) {
+          let prIndex = amended.findIndex(datum => datum.match(PR_RE));
+          if (prIndex === -1) {
+            prIndex = amended.findIndex(datum => datum.match(REVIEW_RE)) - 1;
+          }
+          amended.splice(prIndex + 1, 0, line);
+        } else {
+          amended.push(line);
+        }
+      }
+    }
+
+    if (!containCVETrailer && this.includeCVE) {
+      const cveID = await cli.prompt(
+        'Git found no CVE-ID trailer in the original commit message. ' +
+        'Please, provide the CVE-ID',
+        { questionType: 'input', defaultAnswer: 'CVE-2023-XXXXX' }
+      );
+      amended.push('CVE-ID: ' + cveID);
+    }
+
+    const message = amended.join('\n');
+    const messageFile = this.saveMessage(rev, message);
+    cli.separator('New Message');
+    cli.log(message.trim());
+    const takeMessage = await cli.prompt('Use this message?');
+    if (takeMessage) {
+      await runAsync('git', ['commit', '--amend', '-F', messageFile]);
+      return true;
+    }
+
+    const editor = await getEditor({ git: true });
+    if (editor) {
+      try {
+        await forceRunAsync(
+          editor,
+          [`"${messageFile}"`],
+          { ignoreFailure: false, spawnArgs: { shell: true } }
+        );
+        await runAsync('git', ['commit', '--amend', '-F', messageFile]);
+        return true;
+      } catch {
+        cli.warn(`Please manually edit ${messageFile}, then run\n` +
+          `\`git commit --amend -F ${messageFile}\` ` +
+          'to finish amending the message');
+        throw new Error(
+          'Failed to edit the message using the configured editor');
+      }
+    }
+  }
+}