@node-core/utils 4.0.0

package/components/git/v8.js

@@ -0,0 +1,121 @@
+import path from 'node:path';
+
+import logSymbols from 'log-symbols';
+
+import { minor, major, backport } from '../../lib/update-v8/index.js';
+import { defaultBaseDir } from '../../lib/update-v8/constants.js';
+import { checkCwd } from '../../lib/update-v8/common.js';
+import { forceRunAsync } from '../../lib/run.js';
+
+export const command = 'v8 [major|minor|backport]';
+export const describe = 'Update or patch the V8 engine';
+
+export function builder(yargs) {
+  yargs
+    .command({
+      command: 'major',
+      desc: 'Do a major upgrade. Replaces the whole deps/v8 directory',
+      handler,
+      builder: (yargs) => {
+        yargs.option('branch', {
+          describe: 'Branch of the V8 repository to use for the upgrade',
+          default: 'lkgr'
+        });
+        yargs.option('version-bump', {
+          describe: 'Bump the NODE_MODULE_VERSION constant',
+          default: true
+        });
+      }
+    })
+    .command({
+      command: 'minor',
+      desc: 'Do a minor patch of the current V8 version',
+      handler
+    })
+    .command({
+      command: 'backport <sha..>',
+      desc: 'Backport one or more commits from the V8 repository',
+      handler,
+      builder: (yargs) => {
+        yargs
+          .option('bump', {
+            describe: 'Bump V8 embedder version number or patch version',
+            default: true
+          })
+          .option('squash', {
+            describe:
+                'If multiple commits are backported, squash them into one',
+            default: false
+          });
+      }
+    })
+    .demandCommand(1, 'Please provide a valid command')
+    .option('node-dir', {
+      describe: 'Directory of a Node.js clone',
+      default: process.cwd()
+    })
+    .option('base-dir', {
+      describe: 'Directory where V8 should be cloned',
+      default: defaultBaseDir
+    })
+    .option('v8-dir', {
+      describe: 'Directory of an existing V8 clone'
+    })
+    .option('verbose', {
+      describe: 'Enable verbose output',
+      boolean: true,
+      default: false
+    });
+}
+
+export function handler(argv) {
+  const options = Object.assign({}, argv);
+  options.nodeDir = path.resolve(options.nodeDir);
+  options.baseDir = path.resolve(options.baseDir);
+  if (!options.v8Dir) {
+    options.v8Dir = path.join(options.baseDir, 'v8');
+  } else {
+    options.v8Dir = path.resolve(options.v8Dir);
+  }
+
+  options.execGitNode = function execGitNode(cmd, args, input) {
+    args.unshift(cmd);
+    return forceRunAsync('git', args, {
+      input,
+      spawnArgs: {
+        cwd: options.nodeDir,
+        stdio: input ? ['pipe', 'ignore', 'ignore'] : 'ignore'
+      }
+    });
+  };
+
+  options.execGitV8 = function execGitV8(...args) {
+    return forceRunAsync('git', args, {
+      captureStdout: true,
+      spawnArgs: { cwd: options.v8Dir, stdio: ['ignore', 'pipe', 'ignore'] }
+    });
+  };
+
+  Promise.resolve()
+    .then(async() => {
+      await checkCwd(options);
+      // First element of argv is 'v8'
+      const kind = argv._[1];
+      options[kind] = true;
+      switch (kind) {
+        case 'minor':
+          return minor(options);
+        case 'major':
+          return major(options);
+        case 'backport':
+          return backport(options);
+      }
+    })
+    .catch((err) => {
+      console.error(
+        logSymbols.error,
+        options.verbose ? err.stack : err.message
+      );
+      process.exitCode = 1;
+    });
+}

package/components/git/vote.js

@@ -0,0 +1,84 @@
+import auth from '../../lib/auth.js';
+import { parsePRFromURL } from '../../lib/links.js';
+import CLI from '../../lib/cli.js';
+import Request from '../../lib/request.js';
+import { runPromise } from '../../lib/run.js';
+import VotingSession from '../../lib/voting_session.js';
+
+export const command = 'vote [prid|options]';
+export const describe =
+  'Cast a vote, or decrypt a key part to close a vote';
+
+const voteOptions = {
+  abstain: {
+    type: 'boolean',
+    default: false,
+    describe: 'Abstain from the vote.'
+  },
+  'decrypt-key-part': {
+    describe: 'Publish a key part as a comment to the vote PR.',
+    default: false,
+    type: 'boolean'
+  },
+  'gpg-sign': {
+    describe: 'GPG-sign commits, will be passed to the git process',
+    alias: 'S'
+  },
+  'post-comment': {
+    describe: 'Post the comment on GitHub on the behalf of the user',
+    default: false,
+    type: 'boolean'
+  },
+  protocol: {
+    describe: 'The protocol to use to clone the vote repository and push the eventual vote commit',
+    type: 'string'
+  }
+};
+
+let yargsInstance;
+
+export function builder(yargs) {
+  yargsInstance = yargs;
+  return yargs
+    .options(voteOptions)
+    .positional('prid', {
+      describe: 'URL of the vote Pull Request'
+    })
+    .example('git node vote https://github.com/nodejs/TSC/pull/12344',
+      'Start an interactive session to cast ballot for https://github.com/nodejs/TSC/pull/12344.')
+    .example('git node vote https://github.com/nodejs/TSC/pull/12344 --abstain',
+      'Cast an empty ballot for https://github.com/nodejs/TSC/pull/12344.')
+    .example('git node vote https://github.com/nodejs/TSC/pull/12344 --decrypt-key-part',
+      'Uses gpg to decrypt a key part to close the vote happening on https://github.com/nodejs/TSC/pull/12344.');
+}
+
+export function handler(argv) {
+  if (argv.prid) {
+    const parsed = parsePRFromURL(argv.prid);
+    if (parsed) {
+      Object.assign(argv, parsed);
+      return vote(argv);
+    }
+  }
+  yargsInstance.showHelp();
+}
+
+function vote(argv) {
+  const cli = new CLI(process.stderr);
+  const dir = process.cwd();
+
+  return runPromise(main(argv, cli, dir)).catch((err) => {
+    if (cli.spinner.enabled) {
+      cli.spinner.fail();
+    }
+    throw err;
+  });
+}
+
+async function main(argv, cli, dir) {
+  const credentials = await auth({ github: true });
+  const req = new Request(credentials);
+  const session = new VotingSession(cli, req, dir, argv);
+
+  return session.start();
+}

package/components/git/wpt.js

@@ -0,0 +1,87 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import Request from '../../lib/request.js';
+import CLI from '../../lib/cli.js';
+import auth from '../../lib/auth.js';
+import {
+  WPTUpdater,
+  ResourcesUpdater,
+  InterfacesUpdater
+} from '../../lib/wpt/index.js';
+import { runPromise } from '../../lib/run.js';
+
+export const command = 'wpt <name>';
+export const describe = 'Updates WPT suite';
+
+export function builder(yargs) {
+  return yargs
+    .positional('name', {
+      describe: 'Subset of the WPT to update',
+      type: 'string'
+    })
+    .options({
+      commit: {
+        describe: 'A specific commit the subset should be updated to',
+        type: 'string',
+        default: undefined
+      },
+      nodedir: {
+        describe: 'Path to the node.js project directory',
+        type: 'string',
+        default: '.'
+      }
+    });
+}
+
+async function main(argv) {
+  const { name, nodedir, commit } = argv;
+  const cli = new CLI();
+  const credentials = await auth({
+    github: true
+  });
+  const request = new Request(credentials);
+
+  const updaters = [];
+
+  const statusFolder = path.join(nodedir, 'test', 'wpt', 'status');
+  let supported = [
+    'dom',
+    'html'
+  ];
+  if (fs.existsSync(statusFolder)) {
+    const jsons = fs.readdirSync(statusFolder);
+    supported = supported.concat(
+      jsons.map(item => item.replace('.json', '')));
+  } else {
+    cli.warn(`Please create the status JSON files in ${statusFolder}`);
+  }
+
+  if (name === 'all' || name === 'resources') {
+    updaters.push(new ResourcesUpdater(cli, request, nodedir, commit));
+  }
+  if (name === 'all' || name === 'interfaces') {
+    updaters.push(new InterfacesUpdater(cli, request, nodedir,
+      commit, supported));
+  }
+
+  if (name === 'all') {
+    for (const item of supported) {
+      updaters.push(new WPTUpdater(item, cli, request, nodedir, commit));
+    }
+  } else if (name !== 'resources' && name !== 'interfaces') {
+    if (!supported.includes(name)) {
+      cli.warn(`Please create ${name}.json in ${statusFolder}`);
+    }
+    updaters.push(new WPTUpdater(name, cli, request, nodedir, commit));
+  }
+
+  for (const updater of updaters) {
+    await updater.update();
+  }
+  updaters[0].updateLicense();
+}
+
+export function handler(argv) {
+  runPromise(main(argv));
+}

package/components/metadata.js

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+
+import Request from '../lib/request.js';
+import auth from '../lib/auth.js';
+import PRData from '../lib/pr_data.js';
+import PRSummary from '../lib/pr_summary.js';
+import PRChecker from '../lib/pr_checker.js';
+import MetadataGenerator from '../lib/metadata_gen.js';
+
+export async function getMetadata(argv, skipRefs, cli) {
+  const credentials = await auth({
+    github: true,
+    jenkins: true
+  });
+  const request = new Request(credentials);
+
+  const data = new PRData(argv, cli, request);
+  await data.getAll();
+
+  const summary = new PRSummary(argv, cli, data);
+  cli.separator('PR info');
+  summary.display();
+
+  const metadata = new MetadataGenerator({ skipRefs, ...data }).getMetadata();
+  if (!process.stdout.isTTY) {
+    process.stdout.write(metadata);
+  }
+
+  if (argv.file) {
+    cli.separator();
+    cli.startSpinner(`Writing metadata to ${argv.file}..`);
+    fs.writeFileSync(argv.file, metadata);
+    cli.stopSpinner(`Done writing metadata to ${argv.file}`);
+  }
+
+  cli.separator('Generated metadata');
+  cli.write(metadata);
+  cli.separator();
+
+  const checker = new PRChecker(cli, data, request, argv);
+  const status = await checker.checkAll(argv.checkComments, argv.checkCI);
+  return {
+    status,
+    request,
+    data,
+    metadata,
+    checker
+  };
+};

package/lib/auth.js

@@ -0,0 +1,133 @@
+import fs from 'node:fs';
+import { ClientRequest } from 'node:http';
+
+import ghauth from 'ghauth';
+
+import { getMergedConfig, getNcurcPath } from './config.js';
+
+export default lazy(auth);
+
+function errorExit(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+}
+
+function check(username, token) {
+  if (typeof username !== 'string') {
+    errorExit(`username must be a string, received ${typeof username}`);
+  }
+  if (!/^[a-zA-Z0-9-]+$/.test(username)) {
+    errorExit(
+      'username may only contain alphanumeric characters or hyphens, ' +
+      `received ${username}`
+    );
+  }
+  if (typeof token !== 'string') {
+    errorExit(`token must be a string, received ${typeof token}`);
+  }
+  if (!/^[A-Za-z0-9_]+$/.test(token)) {
+    errorExit(`token is misformatted: ${token}`);
+  }
+}
+
+function lazy(fn) {
+  let cachedValue;
+  return function(...args) {
+    if (cachedValue !== undefined) {
+      return cachedValue;
+    }
+    cachedValue = fn(...args);
+    return cachedValue;
+  };
+}
+
+async function tryCreateGitHubToken(githubAuth) {
+  let credentials;
+  try {
+    credentials = await githubAuth({
+      noSave: true,
+      scopes: ['user:email', 'read:org'],
+      note: 'node-core-utils CLI tools',
+      noDeviceFlow: true
+    });
+  } catch (e) {
+    errorExit(`Could not get token: ${e.message}`);
+  }
+  return credentials;
+}
+
+function encode(name, token) {
+  return Buffer.from(`${name}:${token}`).toString('base64');
+}
+
+// TODO: support jenkins only...or not necessary?
+// TODO: make this a class with dependency (CLI) injectable for testing
+async function auth(
+  options = { github: true },
+  githubAuth = ghauth) {
+  const result = {};
+  if (options.github) {
+    let username;
+    let token;
+    try {
+      ({ username, token } = getMergedConfig());
+    } catch (e) {
+      // Ignore error and prompt
+    }
+
+    if (!username || !token) {
+      process.stdout.write(
+        'If this is your first time running this command, ' +
+        'follow the instructions to create an access token' +
+        '. If you prefer to create it yourself on Github, ' +
+        'see https://github.com/nodejs/node-core-utils/blob/main/README.md.\n');
+      const credentials = await tryCreateGitHubToken(githubAuth);
+      username = credentials.user;
+      token = credentials.token;
+      const json = JSON.stringify({ username, token }, null, 2);
+      fs.writeFileSync(getNcurcPath(), json, {
+        mode: 0o600 /* owner read/write */
+      });
+      // Try again reading the file
+      ({ username, token } = getMergedConfig());
+    }
+    check(username, token);
+    result.github = encode(username, token);
+  }
+
+  if (options.jenkins) {
+    const { username, jenkins_token } = getMergedConfig();
+    if (!username || !jenkins_token) {
+      errorExit(
+        'Get your Jenkins API token in https://ci.nodejs.org/me/configure ' +
+        'and run the following command to add it to your ncu config: ' +
+        'ncu-config --global set jenkins_token TOKEN'
+      );
+    };
+    check(username, jenkins_token);
+    result.jenkins = encode(username, jenkins_token);
+  }
+
+  if (options.h1) {
+    const { h1_username, h1_token } = getMergedConfig();
+    if (!h1_username || !h1_token) {
+      errorExit(
+        'Get your HackerOne API token in ' +
+        'https://docs.hackerone.com/organizations/api-tokens.html ' +
+        'and run the following command to add it to your ncu config: ' +
+        'ncu-config --global set h1_token TOKEN or ' +
+        'ncu-config --global set h1_username USERNAME'
+      );
+    };
+    result.h1 = encode(h1_username, h1_token);
+  }
+  return result;
+}
+
+// This is an ugly hack to get around a bug in hyperquest & ghauth
+// which are not currently maintained
+const originalSetTimeout = ClientRequest.prototype.setTimeout;
+ClientRequest.prototype.setTimeout = function(msecs, ...args) {
+  msecs = Math.min(msecs, Math.pow(2, 31) - 1);
+  return originalSetTimeout.call(this, msecs, ...args);
+};