chore: script

Author: gagik

package-lock.json

@@ -39,7 +39,8 @@
     "test-changed": "lerna run test --stream --concurrency 1 --since origin/HEAD",
     "test-ci": "lerna run test-ci --concurrency 1",
     "test": "lerna run test --concurrency 1 --stream",
-    "where": "node ./scripts/src/where.js"
+    "where": "node ./scripts/src/where.js",
+    "request-npm-token": "request-npm-token"
   },
   "dependencies": {
     "@mongodb-js/monorepo-tools": "^1.1.18"

package.json

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+'use strict';
+require('../dist/request-npm-token.js');

packages/monorepo-tools/bin/request-npm-token.js

@@ -26,7 +26,8 @@
     "precommit": "./bin/precommit.js",
     "depalign": "./bin/depalign.js",
     "monorepo-where": "./bin/where.js",
-    "bump-monorepo-packages": "./bin/bump-packages.js"
+    "bump-monorepo-packages": "./bin/bump-packages.js",
+    "request-npm-token": "./bin/request-npm-token.js"
   },
   "scripts": {
     "bootstrap": "npm run compile",

packages/monorepo-tools/package.json

@@ -7,3 +7,4 @@ export * from './utils/update-package-json';
 export * from './utils/with-progress';
 export * from './utils/workspace-dependencies';
 export * from './utils/get-packages-in-topological-order';
+export * from './utils/get-npm-token-list';

packages/monorepo-tools/src/index.ts

@@ -0,0 +1,69 @@
+#! /usr/bin/env node
+/* eslint-disable no-console */
+
+/**
+ * CLI command to get NPM token requirements for the current monorepo.
+ *
+ * Usage:
+ *   npm run request-npm-token
+ *
+ * This will output the scopes and packages that need to be included in NPM token permissions.
+ */
+
+import { getNpmTokenList } from './utils/get-npm-token-list';
+
+async function main() {
+  try {
+    const requirements = await getNpmTokenList();
+
+    console.log(
+      'Open an IAMSEC ticket with https://jira.mongodb.org/plugins/servlet/desk/portal/81/create/1380',
+    );
+
+    console.log('Use the following description for the ticket:');
+    console.log('--------------------------------');
+    console.log('Hello,');
+    console.log(
+      'We need to update the NPM token for publishing our packages. The token needs Read/Write/Publish access to:\n',
+    );
+
+    console.log('Following Scopes:');
+    if (requirements.scopes.length > 0) {
+      requirements.scopes.forEach((scope) => {
+        console.log(scope);
+      });
+    } else {
+      console.log('(none)');
+    }
+
+    console.log('\nFollowing Packages:');
+    if (requirements.packages.length > 0) {
+      requirements.packages.forEach((pkg) => {
+        console.log(pkg);
+      });
+    } else {
+      console.log('(none)');
+    }
+
+    console.log('');
+    console.log('Please share it with our team lead: {TEAM LEADER NAME}');
+  } catch (error) {
+    console.error(
+      'Error:',
+      error instanceof Error ? error.message : String(error),
+    );
+    process.exit(1);
+  }
+}
+
+process.on('unhandledRejection', (err: Error) => {
+  console.error();
+  console.error(err?.stack || err?.message || err);
+  process.exitCode = 1;
+});
+
+main().catch((err) =>
+  process.nextTick(() => {
+    throw err;
+  }),
+);

packages/monorepo-tools/src/request-npm-token.ts

@@ -0,0 +1,43 @@
+import { listAllPackages } from './list-all-packages';
+
+export interface NpmTokenRequirements {
+  scopes: string[];
+  packages: string[];
+}
+
+/**
+ * Gets all package names and scopes from the current monorepo.
+ * Returns scoped packages as scopes and unscoped packages as individual packages.
+ */
+export async function getNpmTokenList(): Promise<NpmTokenRequirements> {
+  const allPackagesArr = [];
+  for await (const { packageJson } of listAllPackages()) {
+    // listAllPackages yields { name: string, ... }
+    if (packageJson && typeof packageJson?.name === 'string') {
+      allPackagesArr.push(packageJson.name);
+    }
+  }
+
+  // Separate scoped and unscoped packages
+  const scopedPackages = allPackagesArr.filter(
+    (pkg) => typeof pkg === 'string' && pkg.startsWith('@'),
+  );
+  const unscopedPackages = allPackagesArr.filter(
+    (pkg) => typeof pkg === 'string' && !pkg.startsWith('@'),
+  );
+
+  // Extract unique scopes from scoped packages
+  const scopes = [
+    ...new Set(
+      scopedPackages.map((pkg) => {
+        const scope = pkg.split('/')[0];
+        return `${scope}/*`;
+      }),
+    ),
+  ].sort();
+
+  // Sort unscoped packages
+  const packages = [...new Set(unscopedPackages)].sort();
+
+  return { scopes, packages };
+}

packages/monorepo-tools/src/utils/get-npm-token-list.ts

@@ -0,0 +1,110 @@
+/**
+ * This script collects all package names from specified repositories using Lerna.
+ * This is useful for generating a list of all packages we own when asking for NPM token updates.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { exec as execCallback } from 'child_process';
+import { promisify } from 'util';
+
+const exec = promisify(execCallback);
+
+// Repositories to check
+const repositories = [
+  {
+    name: 'devtools-shared',
+    isLocal: true,
+    path: path.resolve('.'),
+  },
+  {
+    name: 'mongosh',
+    url: '[email protected]:mongodb-js/mongosh.git',
+    branch: 'main',
+  },
+  {
+    name: 'compass',
+    url: '[email protected]:mongodb-js/compass.git',
+    branch: 'main',
+  },
+];
+
+// Packages which exist as single repos and are not managed by Lerna
+const manualPackages = ['glibc-version', 'mongodb-mcp-server'];
+
+// Set working directory for cloning repos
+const workDir = path.resolve('/tmp/repo-package-check');
+const outputFile = path.resolve('./tmp/all-packages.txt');
+
+async function main() {
+  try {
+    // Create working directory if it doesn't exist
+    if (!fs.existsSync(workDir)) {
+      fs.mkdirSync(workDir, { recursive: true });
+    }
+
+    console.log(`Working directory: ${workDir}`);
+    console.log('Starting package collection...');
+
+    let allPackages: string[] = [];
+    let allScopes: string[] = [];
+
+    // Process each repository
+    for (const repo of repositories) {
+      console.log(`\nProcessing ${repo.name}...`);
+
+      const repoPath = repo.isLocal ? repo.path : path.join(workDir, repo.name);
+
+      // Clone or pull the repository
+      if (!repo.isLocal) {
+        if (fs.existsSync(repoPath)) {
+          console.log(`Repository exists, pulling latest changes...`);
+          await exec(
+            `cd ${repoPath} && git fetch && git checkout ${repo.branch} && git pull`,
+          );
+        } else {
+          console.log(`Cloning repository...`);
+          await exec(
+            `git clone ${repo.url} ${repoPath} --branch ${repo.branch}`,
+          );
+        }
+      }
+
+      // Check if the repository uses Lerna
+      if (fs.existsSync(path.join(repoPath, 'lerna.json'))) {
+        console.log(`Running npx lerna list in ${repo.name}...`);
+        try {
+          const { stdout } = await exec(`cd ${repoPath} && npx lerna list`);
+
+          // Parse package names from lerna output
+          const packages = stdout
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+
+          console.log(`Found ${packages.length} packages in ${repo.name}`);
+          allPackages = [...allPackages, ...packages];
+        } catch (error) {
+          console.error(
+            `Error running lerna list in ${repo.name}: ${error as string}`,
+          );
+        }
+      } else {
+        console.log(`${repo.name} does not appear to use Lerna. Skipping.`);
+      }
+    }
+
+    // Sort packages alphabetically and remove duplicates
+    const sortedPackages = [...new Set(allPackages), ...manualPackages].sort();
+
+    // Write to output file
+    fs.writeFileSync(outputFile, sortedPackages.join('\n') + '\n');
+
+    console.log(`\nComplete! Found ${sortedPackages.length} unique packages.`);
+    console.log(`Results saved to: ${outputFile}`);
+  } catch (error) {
+    console.error(`Error: ${error as string}`);
+    process.exit(1);
+  }
+}
+
+main();